{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Subdomains tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial is designed to introduce users to the concept of subdomains in Devito and how to utilize them within simulations for a variety of purposes.\n",
    "\n",
    "We will begin by exploring the subdomains created internally (and by default) when creating a `Grid` and then explore in detail how users can define and utilize their own subdomains.\n",
    "\n",
    "Consider the construction of the following `Grid`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import Grid\n",
    "shape = (10, 10, 10)\n",
    "grid = Grid(shape=shape, extent=shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the `subdomains` property we see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'domain': SubDomain domain[(x, y, z)],\n",
       " 'interior': SubDomain interior[(i0x, i0y, i0z)]}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the creation of `Grid` two subdomains have been generated by default, 'domain' and 'interior'. We will shortly explore how such subdomains are defined, but before continuing let us explore some of their properties a little further.\n",
    "\n",
    "First, looking at the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SubDomain domain[(x, y, z)]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['domain']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 10, 10)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['domain'].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we see that 'domain' is in fact the entire computational domain. We can check that it has the same dimensions as grid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['domain'].dimensions == grid.dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, when we look at the 'interior' subdomain we see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SubDomain interior[(i0x, i0y, i0z)]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['interior']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 8, 8)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['interior'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.subdomains['interior'].dimensions == grid.dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This subdomain is in fact defined to be the computational grid excluding the 'outermost' grid point in each dimension, hence the shape `(8, 8, 8)`.\n",
    "\n",
    "The above two subdomains are initialised upon creation of a grid for various internal reasons and users, generally, need not concern themselves with their existence. However, users will often wish to specify their own subdomains to, e.g., specify different physical equations on different parts of a grid. Before returning to an example of the latter, and to familiarise ourselves with the basics, let us dive into an example of how a user could 'explicitly' create subdomains such as 'domain' and 'interior' themselves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `SubDomain` class\n",
    "\n",
    "To make use of subdomains we first import the `SubDomain` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import SubDomain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of how to define a subdomain that spans an entire 3D computational grid (this is similar to how 'domain' is defined internally):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FullDomain(SubDomain):\n",
    "    name = 'mydomain'\n",
    "    def define(self, dimensions):\n",
    "        x, y, z = dimensions\n",
    "        return {x: x, y: y, z: z}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above snippet, we have defined a class `FullDomain` based on `SubDomain` with the method `define` overridden. This method takes as input a set of Dimensions and produces a mapper from which we can create a subdomain. It is through utilizing this mapper that various types of subdomains can be created. The mapper `{x: x, y: y, z: z}` is simply saying that we wish for the three dimensions of our subdomain be exactly the input dimensions `x, y, z`. Note that for a 2D domain we would need to remove one of the dimensions, i.e. `{x: x, y: y}`, or more generally for an N-dimensional domain one could write `{d: d for d in dimensions}`.\n",
    "\n",
    "Now, lets us compose a subdomain from our class `FullDomain`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_domain = FullDomain()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to note that whilst the `full_domain` object has now been initialised, it has not yet been finalised, i.e. it is not currently associated with any grid. To attach this subdomain to a grid we must pass it to the grid during its creation (the subdomain will then be finalised during creation of the grid):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_grid = Grid(shape = (10, 10, 10), subdomains = (full_domain, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we look at the subdomains of `my_grid` we see that our new subdomain 'mydomain' is now present:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'domain': SubDomain domain[(x, y, z)],\n",
       " 'interior': SubDomain interior[(i0x, i0y, i0z)],\n",
       " 'mydomain': SubDomain mydomain[(x, y, z)]}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_grid.subdomains"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected (and intended), the dimensions of our newly defined subdomain match those of 'domain'.\n",
    "\n",
    "Now, let us create a subdomain consisting of all but the outer grid point in each dimension (similar to 'interior'):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class InnerDomain(SubDomain):\n",
    "    name = 'inner'\n",
    "    def define(self, dimensions):\n",
    "        d = dimensions\n",
    "        return {d: ('middle', 1, 1) for d in dimensions}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, note that in the above we have used the shortand `d = dimensions` so that `d` will be a tuple of N-dimensions and then `{d: ... for d in dimensions}` such that our mapper will be valid for N-dimensional grids. Next we note the inclusion of `('middle', 1, 1)`. For mappers of the form `('middle', N, M)`, the `SubDomain` spans a contiguous region of `dimension_size - (N + M)` points starting at (in terms of python indexing) `N` and finishing at ``dimension_size - M - 1``.\n",
    "\n",
    "The two other options available are `'left'` and `'right'`. For a statement of the form `d: ('left', N)` the `SubDomain` spans a contiguous region of `N` points starting at `d`\\'s left extreme. A statement of the form `('right', N)` is analogous to the previous case but starting at the dimensions right extreme instead.\n",
    "\n",
    "Now, to create a grid containing both of the subdomains defined above, 'mydomain' and 'inner', we simply pass these during the creation of a grid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "inner_domain = InnerDomain()\n",
    "my_grid = Grid(shape = (10, 10, 10), subdomains = (full_domain, inner_domain))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If our subdomain `'inner'` is defined correctly we would expect it have a shape of `(8, 8, 8)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 8, 8)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_grid.subdomains['inner'].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is indeed the case.\n",
    "\n",
    "Now, let us look at some simple examples of how to define subdomains using 'middle', 'left' and 'right' and then utilize these in an operator.\n",
    "\n",
    "The first subdomain we define will consist of the computational grid excluding, in the `x` dimension 3 nodes on the right and 4 on the left and in the `y` dimension, 4 nodes on the left and 3 on the right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Middle(SubDomain):\n",
    "    name = 'middle'\n",
    "    def define(self, dimensions):\n",
    "        x, y = dimensions\n",
    "        return {x: ('middle', 3, 4), y: ('middle', 4, 3)}\n",
    "mid = Middle()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us form an equation and evaluate it only on the subdomain 'middle'. To do this we first import some required objects from Devito:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from devito import Function, Eq, Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then create our grid containing the subdomain 'middle' and when forming our equation pass this subdomain to the equation, thus telling Devito to only evaluate that particular equation within the subdomain 'middle':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` run in 0.01 s\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "grid = Grid(shape = (10, 10), subdomains = (mid, ))\n",
    "f = Function(name = 'f', grid = grid)\n",
    "\n",
    "eq = Eq(f, f+1, subdomain = grid.subdomains['middle'])\n",
    "\n",
    "op = Operator(eq)()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result we expect is that our function `f`'s data should have a values of `1` within the subdomain and `0` elsewhere. Viewing `f`'s data we see this is indeed the case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create some additional subdomains utilising `'left'` and `'right'`. The first domain named 'left' will consist of two nodes on the left hand side in the `x` dimension and the entire of the `y` dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Left(SubDomain):\n",
    "    name = 'left'\n",
    "    def define(self, dimensions):\n",
    "        x, y = dimensions\n",
    "        return {x: ('left', 2), y: y}\n",
    "ld = Left()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, our subdomain named 'right' will consist of the entire `x` dimension and the two 'right-most' nodes in the `y` dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Right(SubDomain):\n",
    "    name = 'right'\n",
    "    def define(self, dimensions):\n",
    "        x, y = dimensions\n",
    "        return {x: x, y: ('right', 2)}\n",
    "rd = Right()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that owing to the chosen definitions of 'left' and 'right' there will be four grid points on which these two subdomains overlap.\n",
    "\n",
    "Then, let us create a grid consisting of the subdomains 'middle', 'left' and 'right' and specify an equation on each of the three subdomains:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = Grid(shape = (10, 10), subdomains = (mid, ld, rd))\n",
    "f = Function(name = 'f', grid = grid)\n",
    "\n",
    "eq1 = Eq(f, f+1, subdomain = grid.subdomains['middle'])\n",
    "eq2 = Eq(f, f+2, subdomain = grid.subdomains['left'])\n",
    "eq3 = Eq(f, f+3, subdomain = grid.subdomains['right'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then create and execute an operator that evaluates the above equations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` run in 0.01 s\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "op2 = Operator([eq1, eq2, eq3])()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Viewing the data of `f` after performing the operation we see that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data([[2., 2., 2., 2., 2., 2., 2., 2., 5., 5.],\n",
       "      [2., 2., 2., 2., 2., 2., 2., 2., 5., 5.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 1., 1., 1., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.],\n",
       "      [0., 0., 0., 0., 0., 0., 0., 0., 3., 3.]], dtype=float32)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seismic wave propagation example with subdomains\n",
    "\n",
    "We will now utilise subdomains in a seismic wave-propagation model. Subdomains are used here to specify different equations in two sections of the domain. Our model will consist of an upper water section and a lower rock section consisting of two distinct layers of rock. In this example the elastic wave-equation will be solved, however in the water section, since the Lame constant (`mu`) is zero (and hence the equations can be reduced to the acoustic wave-equations), terms containing `mu` will be removed.\n",
    "\n",
    "It is useful to review seismic tutorial numbers 6 (elastic setup) to understand the seismic based utilities used below (since here they will simply be 'used' with little explanation).\n",
    "\n",
    "We first import all required modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from devito import (TimeFunction, VectorTimeFunction, TensorTimeFunction,\n",
    "                    div, grad, curl, diag)\n",
    "from examples.seismic import ModelElastic, plot_velocity, TimeAxis, RickerSource, plot_image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now define the problem dimensions and velocity model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "extent = (200., 100., 100.) # 200 x 100 x 100 m domain\n",
    "h = 1.0 # Desired grid spacing\n",
    "# Set the grid to have a shape (201, 101, 101) for h=1:\n",
    "shape = (int(extent[0]/h+1), int(extent[1]/h+1), int(extent[2]/h+1))\n",
    "\n",
    "# Model physical parameters:\n",
    "vp = np.zeros(shape)\n",
    "vs = np.zeros(shape)\n",
    "rho = np.zeros(shape)\n",
    "\n",
    "# Set up three horizontally separated layers:\n",
    "l1 = int(0.5*shape[2])+1 # End of the water layer at 50m depth\n",
    "l2 = int(0.5*shape[2])+1+int(4/h) # End of the soft rock section at 54m depth\n",
    "\n",
    "# Water layer model\n",
    "vp[:,:,:l1] = 1.52\n",
    "vs[:,:,:l1] = 0.\n",
    "rho[:,:,:l1] = 1.05\n",
    "\n",
    "# Soft-rock layer model\n",
    "vp[:,:,l1:l2] = 1.6\n",
    "vs[:,:,l1:l2] = 0.4\n",
    "rho[:,:,l1:l2] = 1.3\n",
    "\n",
    "# Hard-rock layer model\n",
    "vp[:,:,l2:] = 2.2\n",
    "vs[:,:,l2:] = 1.2\n",
    "rho[:,:,l2:] = 2.\n",
    "\n",
    "origin = (0, 0, 0)\n",
    "spacing = (h, h, h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before defining and creating our subdomains we define the thickness of our absorption layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "nbl = 20 # Number of absorbing boundary layers cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now define our subdomains, one for the upper water layer, and one for the rock layers beneath:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define our 'upper' and 'lower' SubDomains:\n",
    "class Upper(SubDomain):\n",
    "    name = 'upper'\n",
    "    def define(self, dimensions):\n",
    "        x, y, z = dimensions\n",
    "        return {x: x, y: y, z: ('left', l1+nbl)}\n",
    "    \n",
    "class Lower(SubDomain):\n",
    "    name = 'lower'\n",
    "    def define(self, dimensions):\n",
    "        x, y, z = dimensions\n",
    "        return {x: x, y: y, z: ('right', shape[2]+nbl-l1)}\n",
    "\n",
    "# Create these subdomains:\n",
    "ur = Upper()\n",
    "lr = Lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create our model to which we pass the subdomains `ur` and `lr`. Within model they will then be used when creating the model grid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `initdamp` run in 0.04 s\n",
      "Operator `padfunc` run in 0.01 s\n",
      "Operator `padfunc` run in 0.01 s\n",
      "Operator `padfunc` run in 0.01 s\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "so = 4 # FD space order (Note that the time order is by default 1).\n",
    "\n",
    "model = ModelElastic(space_order=so, vp=vp, vs=vs, rho=rho, origin=origin, shape=shape,\n",
    "                     spacing=spacing, nbl=nbl, subdomains=(ur,lr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now prepare model parameters along with the functions to be used in the PDE, and the source injection term:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = model.grid.stepping_dim.spacing\n",
    "\n",
    "# Source freq. in MHz (note that the source is defined below):\n",
    "f0 = 0.12\n",
    "\n",
    "# Thorbecke's parameter notation\n",
    "l = model.lam\n",
    "mu = model.mu\n",
    "ro = model.irho\n",
    "\n",
    "t0, tn = 0., 30.\n",
    "dt = model.critical_dt\n",
    "time_range = TimeAxis(start=t0, stop=tn, step=dt)\n",
    "\n",
    "# PDE functions:\n",
    "v = VectorTimeFunction(name='v', grid=model.grid, space_order=so, time_order=1)\n",
    "tau = TensorTimeFunction(name='t', grid=model.grid, space_order=so, time_order=1)\n",
    "\n",
    "# Source\n",
    "src = RickerSource(name='src', grid=model.grid, f0=f0, time_range=time_range)\n",
    "src.coordinates.data[:] = np.array([100., 50., 35.])\n",
    "\n",
    "# The source injection term\n",
    "src_xx = src.inject(field=tau[0, 0].forward, expr=src*s)\n",
    "src_yy = src.inject(field=tau[1, 1].forward, expr=src*s)\n",
    "src_zz = src.inject(field=tau[2, 2].forward, expr=src*s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now define the model equations. Sets of equations will be defined on each subdomain, 'upper' and 'lower', to which we pass the subdomain object when creating the equation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "u_v_u = Eq(v.forward, model.damp * (v + s*ro*div(tau)), subdomain = model.grid.subdomains['upper'])\n",
    "u_t_u = Eq(tau.forward, model.damp * (tau + s * l * diag(div(v.forward))),\n",
    "           subdomain = model.grid.subdomains['upper'])\n",
    "\n",
    "u_v_l = Eq(v.forward, model.damp * (v + s*ro*div(tau)), subdomain = model.grid.subdomains['lower'])\n",
    "u_t_l = Eq(tau.forward, model.damp * (tau + s * l * diag(div(v.forward))\n",
    "                                      + s * mu * (grad(v.forward) + grad(v.forward).T)),\n",
    "           subdomain = model.grid.subdomains['lower'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now create and run an operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Operator `Kernel` run in 10.68 s\n"
     ]
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "op = Operator([u_v_u, u_v_l, u_t_u, u_t_l] + src_xx + src_yy + src_zz, subs=model.spacing_map)\n",
    "op(dt=dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, plot some results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAADbCAYAAADXsW4lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztvX90VdWZ//968otLuIQQAoQQMGBQSkFRUZnW9kMVFTuMOl12qq1WWx0/WplpZ41ramf6bbuqXTqf6bR2xrYuq462ttKWqdRxrBatTGFGWlBpwRpLBlONEiSSK0kl5tf+/rH3vmffk3tzA5d4SXhea11zzz7n7LPPMZx3nmc/+3nEGIOiKIqiHI2UFHsAiqIoipILFSlFURTlqEVFSlEURTlqUZFSFEVRjlpUpBRFUZSjFhUpRVEU5ahl1ERKRFaJyIsi0iIiN43WdRRFUZTxi4zGOikRKQV+D5wLtAFbgcuMMb874hdTFEVRxi2jZUmdAbQYY3YbY3qBtcBFo3QtRVEUZZxSNkr9zgZeCbbbgDNzHVxdXWvq6xtHaSiKoihHDy+88EyHMWY6QJOIeauAvvbA48aYVUdoaEcloyVSkqUtw68oItcC1wLU1c3lgQe2jdJQFEVRjh5OO03+4L8fBK4voK8vQG3hIzq6GS13XxswJ9huAF4LDzDG3GWMWWaMWTZ16vRRGoaiKMrRTUkBn2OB0brPrcACEZknIhXApcDDo3QtRVGUMYmgIpWPUXH3GWP6RWQN8DhQCtxrjHl+NK6lKIoylhmtOZfxwqg9H2PMo8Cjo9W/oijKWMdbUkpuVMQVRVGKiIrU8KhIKYqiFAlBX8L50OejKIpSRLKt11EiVKQURVGKhADlxR7EUY6KlKIoSpHQwIn8qEgpiqIUERWp4VGRUhRFKRIaOJEffT6KoihFRC2p4VGRUhRFKRJqSeVHn4+iKEqR0MCJ/KhIKYqiFBEVqeFRkVIURSkS6u7Ljz4fZczQ11d4H+W6clI5ylBLanhUpBRFUYqEYGsZKblRkVKOOoazmAYGDr2/0uAt0NeX3Zoqy/EvIWzv7899jeH2KcpwqEgNj4qUUnRyiZIXpFAARiIGobCUldl+hhOq+PHxtmzb8XFkG6MKl5IPje7Lj4qUUjTi4hQXpf7+6BO2h8QFJpvIlMb+VI1bUv390fH+u7+W7zPs2/cZWnXxccb7VMFSsqGBE/nR56MoilJE1JIansMWKRGZA3wXqAMGgbuMMd8QkRrgh0Aj0Ar8hTGms/ChKuMJb0WF1khPT6bV0dNjj4vPQ3nLaOLETAsnkbCfuNUT4vsPrbi4RVRWFl2jvNxu+74BJkyw7RMnDu3b39vAgB1/eE21qJRsqEgNTyGWVD/wt8aYZ0VkMvCMiGwArgKeNMbcJiI3ATcBny18qMpYJ5t7zwsT2O8HD8Lbb9vt+AvdC0UyabenTIHJk6NtLx7xYIe+vqjPnp5I/AD++MfMMRw8OHTcEydmilR1tb3mpEmZ++PuvbDPt9/OvI4KlgIa3TcSDlukjDF7gD3ue5eIvADMBi4CVrjD7gc2oiJ1zBO3nPr7I8Ho7rZtfjskmYxEqLbWfqZNs9vTp0NJz1tRB/39MEBk+gBUJ+ntL0kf4q8TH4ff392dOY5wbioUqepqOxY/rmnTYOpUu11RNkgF/ZCw/7wSiZL0NcJ+w3tVwTo2eSdESkRWAd9wl7rbGHNbbP8ErFfsNOAN4CPGmFa373PA1dh/WX9tjHl8hH3+K/AJY0yy0PEfEUtTRBqBU4BfATOdgHkhm5HjnGtFZJuIbOvs3HckhqEoijLmKCvgkw8RKQW+CVwALAIuE5FFscOuBjqNMU3A14F/dOcuAi4F3g2sAr4lIqX5+hSRZUD1oT2F3BQcOCEiSeDfgc8YYw6IyIjOM8bcBdwFsGjRMlPoOJSjj1zuPbA/u7oid5tvCy2W2lqoq4OGBrs9t2EQ2tthb4dteDGVaYJ4X2AymeF76++vSI9lJBZLTw+kUvZ7fIz+MpMmWUsO7Pj8x26XUF1dYa08oAKoSJSRSFRkWI3x8ag1dezxDoSgnwG0GGN2A4jIWqy363fBMRcBX3Lf1wF3iH2RXwSsNca8DbwkIi2uP3L16QTsn4CPAn9+JG6gIJESkXKsQH3fGPMT17xXRGYZY/aIyCzg9UIHqYw9hnPvgRUB7/7yx06caIXJv+ybmqA+eQBaWmzD9jbo6IgmjsrLI98bWPVwPsG3+isA6OrMFBk/F+QDI5LJzHmunp5MF2NHR9Tuv3d3Z4aYT5sGc+bA8cfb7Xe9y469sbESgMqyXujpoYIeaqptx2/1lFBaasfm+/fjU44tRlmkZgOvBNttwJm5jjHG9IvIm8A0174ldu5s9z1Xn2uAh937/4jcQCHRfQLcA7xgjPlasOth4ErgNvfzpwWNUBlTxKPmwqCIzs7opZxKRS9mrzGNjbBwIcyvPWAbtm+H5mZrPYFVBy9EYJWhsdF+gANU0d4Ona9E1wnnlPzPCROiyDxvuYXBFqGYdnTAvn3Q2mo/YH+++mo0rJYW+M1vrNUH9h5OPhlOOcVuL15cQX1dmb1pZ6JVJhIkplem12zlmgtTxjdHYJ1UrYhsC7bvcl6q8BJx4p6rXMfkas+mq0ZE6oEPE8UkHBEKeT7vBa4AdojIdtf291hx+pGIXA28jB20cgyQTaC8e8u/n7u67Pbbb1thqKuDd7/btp1+OpRs+R94xP2ba26OhAnswYsXw9KlALzVcALNzdD6hN3d3m77D0PKQw8gWEEMQ9STyShaD1wgRujbayyDZJL9qRJ27bJNL75o9XP79miYe/YMsGePfQA7dyZ47jl4/nm7/6yzYPnyEhYurKGie3/6gZQkeqhxCl1WVpJ2MUJmJKAyvinQ3ugwxiwbZn8bMCfYbgBey3FMm4iUAVOA/XnOzdZ+CtAEtDgrqlJEWtxc12FTSHTfZnI/33MOt19FUZRjBQFGOTH/VmCBiMwDXsUGQnw0doz3fj0NXAL8whhjRORh4Aci8jWgHlgA/NoNe0ifxpjnsetmARCR7kIFCjTjhHKEiM9BedeVtw46Oux3bx1MmmS9dKefDvPZbRvvfgK2bYv8amAPWub+UFyxgteSJ7DFecl3rrWHhhHoZWWRdQSR5ZTMEQjrraqS/l7b0N1tBxvGpB88SE15OWe6Ts9c2cDq1fVs3mwP2bgRNm4s5bnn/LN4neZmaG62sfLNzaW0tsKKFbB8eQ0AVYn90eQWUFVdTVlthVpTxxijHTjh5pjWAI9jw8XvNcY8LyJfBrYZYx7GTtt8zwVG7MeKDu64H2GDLPqBG4wxAwDZ+hyte1CRUgoi7uLznrLu7owpGDo67At3yhS7/a532Zd21bZfwGOP2cYtW+wJfs5p+XJYvZrXGt8DwCOPwObNURyFD2SIRwOGIlVbm+nO88f6l396/VS1DbSorI5FznZ32wmuffuiia6yMmqqq7lw4UIAVn/1PTzyCKxfb6Mx1q+fQWfnHuBFALZuraK5uYHW1mjMK1bUUJ8MBtDRYa9dXZlxeZ2jGv+MdsYJY8yjwKOxti8E33vIMS1jjPkK8JWR9JnlmILXSIGKlFIA2eagwug9bz2BbZ82LQomOG9FL6xdC+vXkzZBBgbsnNPFF9vta67huw+UsM4tE9y2zc47uT/mmDq1lIYGmO3ijRobbSyFX/QLUfSen4PyUX2hSIWLeROJCpLJGVQvtMv7Smpr7UUTicjCa2uzE1HOpCt54gkuPO00Vt35p4A1/O67bxZbt/plmn+gq+sNHnxwHm1tVenns3p1DXP9P2P3wCr9wLOIlQrV+EMTzOZHn4+iKEoR0dx9w6MipRwRfCSfd2d1dNiPt6xqa+3809nLXHj5HXfDj39sQ+QmT7ZtK1bAddfxq0lnA/DNq6yh1dX1hrtKL1DF9Ok2ad7ixXDiibBggd07e7ZdYOvnoSB7HagwwayfQwvngsIFxcnkDGobZlDT1BT5GZubYefOaHvzZti2jYr/+i8APrV6NWfd/X5uu81aYw8+OAnYDjzLpk3HAbBv3zy6uuDDH7ZzVPOrg4cG1qKqrhxSpkStqfHHkVlNNH5RkVIOC/+SDxO3ehcfRALlp3iWLYOzF78Ot99pGx54gP5duyibPDly733+83zrkbncfrvd3LVrD9ABeJ9YA0uWlLN8ud1autQumvXrk6qr7RqokLgbEoa+6LMlfo3n7JsypZJZs04CYO7FC61vcetWe9Azz1jR8jHq27Zx0qpV/OCBGwFoaprEzTcvB/4H2AFAc/MBvvGNk9MieemlNcyv7o8eIFaoqgO3X5h/UMVqfPAORPeNeVSklEMmtEL8y7+zM8MQoLvbioZb0sR5y/bD7XfAd75j97e3kywvh6uuwqvS9TeUcOedPfgXubWc6pk8eR5gDa0VK6I+GxutheatHogEJsxmfqgv9FDUfH/t7dGUVMv0Chobz2D+FQujgVRXkw73e+45eOEFK1zAl2+8kYaGk1iz5n309T3prtLMnj0Huf12q7ilpXDFFTOoTwaRJ0CVU+D+ZMWQcSljH63Mmx8VKUVRlCKhgRP50eejHBbeivIuqDffzFxelEjY9EAXrnLrj267A/71X9nvJn+qAK67jgO3/AuXO2/ff/zHS0AzNiUrQBPz5h2X9gauWGHnoXxuvwpc327iqbe/JG1Fheu18pWgTySGJpD1+PN9SD3A3r02wK+lzkbqnbzsT5k5b17kd3zkEdiyhcHvfQ+Akl27uPZzn2PK9y7kiivsOve+vv8Efse+fXag3/jGe5k8GS6/fK59Pj2/txd091ZTV0dfX0mGG1KtqfGBWlLDoyKljJgw5Ny7nuKLdT2NjbB6NXCnm4O64w7aU6n07FLZJz7B/i/9C6tXwdNPP+taX8TKl836f/rps7j0UitOYAWqoucAdGdOGPX223/mPpw8m1ssl0j5kPRw/VSYPDas0uv77OrKDBJpb4cTT1zEmdc59ayttSc+9ZQd15YtJNes4SO3pOB7Hwfg0kvPA34CWJfgnj2l/Ou/Lk/XyvrIh5tsgIZ/qGVlTJ06IyNhb7b7UcYW6u7Lj4qUMiKyLdqNL9bt67PrlMAt1H3iJ3DHHQC8tm8fZUDyggsAGLz7XlafBU8/vQlrPQFMBU7l3HNnAXD55bByJdRXv+Uu4i7mV+Ymk7zVU5KRDzBXkET8Ze4Tu/r7Kg0qz4VWis9IUV6eGbjghQqigJG9e61ltfLST1JZXU2JU7qyDRt4/ZVXmPHpT/ORf7Yd//GeT3L11R8gyr/8LM3NE7nnnpMBmDWrhPcvrLUmm7tIRSJBMmmv4TN6qEiNffQlPDz6fBRFUYqEWlL5UZFSRkw4z+PnaHJF8y3q/6118bmw7F6gfsGCtPtv1Sp4+umN2PVDLssCy/mzP5vFNdfYrZUroTL1GrQ706isDKqrGXTWRHf30JLs4fyTbxuO8vJMK7E0VsvbW1Jh5vQJE+z3zs7oGu3tmZbV+ed/iJnuhER/Pz1PPcXLqRRzb7gBgE9+v5rW/+9D3HyzryH3c2ALGzZYf9/xxzfQ+LkZzE2mogfc0UFVo7UiDx4sSbsl1Zoau2jgRH70+Sh5iVe1DUXKv6hLS+081AdXDdqGNXdy4Kmn8NNUTQBf/SrX32oDAzZs+G9sPbUq4HQAVq1q4Lrrgj5aW6MqhADV1fQmqugO3tvxNU7hz5FSHixUyeb+g8xiv97957fLyzPn5HbutONatepCAOau6ae6s5Oe7dtpcYradPXVfPm/mti61br3HnvsD8AzwEYA7rnncpYsgU9d55JIb9+eMRE2deqMtHtTRWpso5bU8KhIKSMiXsDQW1F+MW9dna2bxAMP2IZ/+zfaAJ+utexv/obvpi7kzjtfdC0b3c9T+ZM/ORGA66+HD67shWaXyaG/PyNbbG+iKqNwYr5FuodDfK4KhgZXhFaV34bIquzstELlx3PxxR+i/q9S1P3DP9DiKiX+PpXihMsv59+3/BaAadMupKfnD/iktH19T/LAA+dw2mn2FXbmLJdD0ClhRTJJMllJT090fRWrsUlBFWxNvH7h+ENFSlEUpViIZK55OFTCVevjFBUpJSfZQs4hiurr7o7SEC1cCCdVvwx33w3A7p4eBnHzUMCBL32NK6cMYOurAXQC72XOnOWsWWNbLlw9CDubM+vK19bSm7BzUN6Kis9BjQblsVw1fX2ZLsAws7r/GbpFUynYsSM6/qqrPkllWxtzv/hFwBbo2b1jB/PXfBKAe+65l4997P3AD90ZW3n66RP56U9tWPuSz8+lMlyIlkqRrK0MS1KpJTUWERmaYFLJoOCnIyKlwDbgVWPMaletcS1QAzwLXGGM6S30OkrxiOe/8/NR/f3R+tWzzgLWrqV70ybAVk5rBLjlFsCGk8MD4Ascsgg4jxtugEsucU07d0YRGJAWKD/v5QWqGC/lMMCitNR+siWv9YRryHbsgHXr4ONr1lDhUiXV/vjH1h36b/8GwEcvvpi7P3AhTz31jOvhN8Am1q69DLBBJGc3xULSq6vTLj/QIIoxSUlJYZaUX38xjjkSEv5p4AVcEgHgH4GvG2PWisidwNXAt4/AdZQi4rMuQGRFlZXZBK8A8/t/Dw88QKs7vgyofd/7+Hn1XwDwH//xLDZQwv+DXM5ll03issugouV3UcfJZLoY1GB1DZ1BrcF49oh3mlxrq+KFFMHO1XnxePNNWwurrq6G85zZ2LBlC6+/8gq/d8cv//SnufvJCzn++HNcy4vADl566VQAHnnkRJbf4qwpSP+l4K0pf30VqTGGWlJ5KSiwREQagD8F7nbbApwNrHOH3A9cXMg1lOKQzdXnQ75TqSjD+bJlrrr7+vWkduzgAHAAaAD40pe47jq47jqAR9yeJcAS5sw5nauugrm8bAMC2tvTIea+amEqFVlPxRaokLgrsLTUClUyGcV5+MKLPvlEe7stM7+74f3sbng/XHMNc4G33Of3ra3MX/f/uOyy47jssuOw8ZAdWGHfwvr1VuiorrYf91dDBb1MmBCFxev7bgwSX+dwKJ9jgELv8nbg7wBXEIhpQMoY418lbcDsbCeKyLXAtQB1dXMLHIaiKMoYpFB33zHAYYuUiKwGXjfGPCMiK3xzlkOzxkgaY+4C7gJYtGjZ+I+jHINkW7wLkauvsREW1b5uGx96iJeJfqFqly7l4e6zeeklX5rid8BM4L2ArdBx3spB2NgSmUfOBDnQPTQXHxwdVpQn2yLg8F1TXZ05h+dLfTz2mG371DXXUPvQQ1Rt3w7Ay8AJn/88X239OwAefPAD2Hkp6wp96aWX2Lx5Hu+/0eUH9KuHu7uZONEWTvRuUWUMoe6+vBTydN4LXCgiH8RONFRhLatqESlz1lQD8Frhw1SKQSgOYcbznh6YNMlG9LFhg23bsoUUzs0HcOONfPazAF6keoDFLFxo10Rdcgl2gerBgzB1qj3EL9btiK5ztLj4shGfo/LvmkQiU6Rqa6OISKdJ/Oq0es78xCeY++lPA/A68Nu+Pk5a9y8AvO99f+2q+Lr5Op7hscfmcemlNkP8/GQyLVLJBitSPmn60fq8lCyoSOXlsJ+OMeZzwOcAnCV1ozHmYyLyY+ASbITflUQZNJUxQmghQOZ8lGf6dJcC6QErQi8Dg8B89+be/Scfo7l5C35xqk0eewaX2WA1Tmo8AJv22I0gmi9MczRWEqh6qyoeou5vq7vbCpW3qMDOT535iUuZ4RLwJnftog046dZbAfj8/X/N+eefTFQA8kU2bepj+3b7fOcvq05HsJT02AS8Eybo4t4xR6HrpI4BRkPCPwusFZFbgOeAe0bhGoqiKGMftaTyckSejjFmIy7PjTFmN3DGcMcrRz/xNEihhQN2fVRNajc88QRg49AqAS69FIDbbgP7K+GXyM1j6tSTOf98t9ncbOO0fQgc8FZ/xZDrjBXi66hcqSsgCshLJiNL6sUX4dm2GZzqFonV3XorvwV2uwPOq30WeD/R4uc/ADvYssWGpH/o4ga7Zip4YBMnVuq81FhDAyfyohKu5CQUKf8B+2+qsRF4+mkOvPIKYMOo54ONiAC+c04fkasKYCkXXwxnnuJE67Eg5NwlkI3XSMrnroq7JXMRDxkfLcI5qlCkfFj6pEmRS3DPHtiyBU5dvRqAxltv5XeQXmc2//bbueyy7/Lgg8e5lmeAF9Mi9XJbCXN9SWHnh03U1WREJqu7b4ygltSw6NNRshJmmPDvQf/SSybdIt47n8HF9jGIDZrY3Xi2a/k5dl2UC4rgZFauxFpQvlNnYvSWVQKZ18jGSEVpuPPeKcEKM1L4NVRTp9rS82Cnk5qb4a2r3gNA5fLlVG3ZQofvYO1arnrkuzz44Imu4dfAbrZutVstLTC3IZlhSVWUDVJWpjm1xxTq7suLPh1FUZRioe6+vOifXUqavr6hmSa8RRUmW66uhhOaBmHbNvZj8/SVARWnn84DD/hqHc+6oxuABqZPP85mpvDZJfr60ika4hklwrBzP6bDtaKOBIe60N9ba/7YRMK6+qZMibJSgJ1S2rLFfjj3XGZgZ/B6gd19fZy39HV8hg6YCLxOT08bPT1ttLQQhQ8G/lhvwR1DCQnGNt6SGsWMEyKySkReFJEWEbkpy/4JIvJDt/9XItIY7Puca39RRM7P16eIfN+17xSRe0WkYN+F/horWenvj4Shry9a2AsuzqGlBZqb8VHplQArV7J+vT9ql/s5D7AJaE9o7IXtbkXwxInpN/bBoMJtyJEUpiPt5sv2fgjHH16vrMze7uTJVqx8W3d35P08+8wzmRH09Row/8c/ZupUW8m3s7MKmzn+DwC0tDRkipT7OXFiJW++WejdKe8YoxyC7hKAfxM4F5sBaKuIPGyM+V1w2NVApzGmSUQuxeZf/YiILAIuBd4N1ANPiMgJ7pxcfX4fuNwd8wPgGgrM3aoipQzBR/Z5YfIVYP2LuboaaG2lZ9++dOxeHcCKFTx36wHX4mer7MT/0qVY0yEsw5FM0ktFunCit6Di4hQKZEi8eq7nSAuSF598f7iG+0PBCi2qyS6BWCJh56VaW91Bl5zOjPJyKtzNdwA8+SQrVliReuihqcAe97F/IxzoqaAqXL3b309ZQi2oMcXoz0mdAbS4qGtEZC1wEdEqcdz2l9z3dcAdLg/rRcBaY8zbwEsi0kIUuZ21T2PMo75TEfk1wfr+w0V/nRVFUYrF6IvUbOCVYLsNODPXMcaYfhF5E5uHdTY2w3F4rs/FOmyfzs13BbZKRkGoSCk5CUPB+/sjr0RtLdDaSgrwBkMVwPLlRBkmPNaSOvFEokVCYDtLJIaEnIdWVDYLKm49xa2mfG64OIW4FId7t8T3udtNz0clEnZcvvLG/rIZ1CxcSKWrlHgA4OmnOfMzdv9DD83AhvS/AVgLrKMDa0kF7r6yarWkxhSFB07Uisi2YPsulxfVM5J8qrmOydWeLZYh3ue3gF8aYzZlOfaQ0F9nJSth8IL/7gViyhSgvZ23guOrgd0dVfg5E0sVMAtw66reDPIquTd2GOrurxcXp1CY4nM94c9c95HLDReSy6WY7ZhsbsZsYwjbvLvPVzL27yWftLetDWqamtIi9TrQ097O6af7HmqBAey8lNX7VIohNxe/pq6VGgMU9ldFhzFm2TD724A5wXa2fKr+mDYRKQOmYOOhhjs3Z58i8kVgOvB/R34buVGRUnISX1TrBWLqVKCjgzAxRBL4ZTNEc1EAk0i40u/TpwN7gzNc/fWe7sxIvlAsvBjEo+U8h2I15XtZ+2v56w93fFxMS0vt2MNxxvFjnzgxc9tHTba3w0kNDemSkINAiqiopP0zAMCmlEhXkq9NREqnijT2GH1331ZggauY/io2EOKjsWMexuZZfRqbd/UXxhgjIg8DPxCRr2EDJxZgF+xJrj5F5BrgfOAcY8zgkbgBFSlFUZRiMcrrpNwc0xrgcaAUuNcY87yIfBnYZox5GJtf9XsuMGI/VnRwx/0IG2TRD9xgjBkAyNanu+SdWHfK0zb2gp8YY75cyD2oSClDiFtQ8ei2RAJIpeglcE5Pn05bG7jZFMcka0HhIgJDn6GbpIn/8R937YXWU/xn/Ny4i3Ik5IoEDC2rXH3GI/hCy8qPPewvvBdfSdefY62i2gxLqhuYn46NqsK+D6zp1dfXQ3d3Auoy/wmXoFknxhTvQMYJF3H3aKztC8H3HuDDOc79CvCVkfTp2o/4zahIKVnJ9pIPX7D09JBxyKRJdHaCf4laKtLrghIJ12ngExuMzb/G3WW51izG58pCdyEMP78UdyGG14t/D6/n8/GF1w33h3NfXnzCaw0MZN5LXBx7eoBkMuMfZC9Q0u1FfyJWpAbSe/v7Y3+Bq7tv7KGlOvKiIqUcHvEXYnm5E4fQDT2yCIO4hRT+m40tA8oItOjri9ZwDcdwi/OzzXPlEqpwHAcPZlYuju8P+/HWWLa1U2H/YcOg+0Qp4UuDPQADQ85RxiCauy8v+nSUwyP+D6uvz1kOoXU0kBmIEDunhEEmTCgZ8vL2eEHy+7u6MkUpHhXozz/UlEDxCMD4OLJZcslkZgLeMEt83MILz4u7Dr21NWGCbQwlvgQCxR4IW4FSOy61nsY2KlJ50aejKIpSLNTdlxcVKSUrw4V3v/02kEhk/vL88Y82NJ2KoLEnHR3d3T104anPNeeJu8V6eiLrKThliPEQugtdZHu6LdscVLZ7yhocEus7jPmAaA7s7bczyjpltaz8MwhvP2TiRCCVypjnqwAGk1Vu6yDWmipN7x3y/0j/Ih97qCWVl4KejohUA3cDi7Erjj+JTTnwQ6ARW8PtL4wxnQWNUnlHyRdN19MDVFfbl6g/ad8+GhrA5Z5wdKczKqRSUF9aGr2du7shlSJZV5mx7ih82Xd3Z77YvSiEARY+kwNYl9nEiUNdddmCHOJBFrmEz0fqhdfx3/2ap4kT7RyV39/dbcXV48XW348/xpfUAvezvT299qwEm7Q3StIRBlBAeXnCZq+IDXyQEvUAjiW0VEdeCpXwbwCPGWMuEZEK7L+rvweeNMbc5lK43wR8tsDrKEUgLlIaiIobAAAgAElEQVT+xd7ZSUa4NNhwabvwNMzlfQBjbBqfjo5p9m3vFSeVgu5uSvp78dZXd7ft22fxjpeSLy21CVp9aqFkMjPVUGjteLJZZ9lEKz6fFH8OoUj5chthiqOJEyPRmjAhU8Q6OqLrhpZld7dLMYX72daWzuJRgl2+u6XZjyKFtaQmpY9PJt0NjST1hnJ0opZUXg776YhIFfB+4CoAY0wv0CsiFwEr3GH3AxtRkVIURRmKilReCnk684F9wL+JyMnAM9iMtzONMXsAjDF7RGRGtpNF5FrgWoC6urkFDEMZDeKLaMOFp2++CdTVURkcfwA4oeEtMjPz9+BTeu3ZMw1mJSKTpasr/d27wDo74Y03IleZX2vkLRJXbT7tIvOWVDjOuGUEhx4A50Pb4+eG68SmTo0sKT8mvz15sh1z6MXx4/FpkFKpTBdhQwPw0ktpS6oCqJw+ne3bfQ8d2Pmoqenja2uB9swBxq1E5ShHAyfyUohIlQGnAn9ljPmViHwD69obES5T710AixYti2fQVY4C4iLlX7QdHUBjI9VEv0AHgPotW4CTY73Y+ketrUtgQTIz+qK/n14q0i4wL1BeDBMJ+/IPXWLV1VCZcDNhQ+ZjKtICFQYoDJeJwmd+8Pfqz/PzXt7lGHcDvvFGpkjV1kbjnDIlqunor9ndPVS0BgaiY6r698P//m96TqoSYNkyW7UXsCJVjq2gYEWquhpoC+LnXQYPFacxhFpSeSnk6bQBbcaYX7ntdViR2isis5wVNYvMjKPKGMCn8AnX8IQilUoByxpJTJ9OYt8+wM5JsXkzCxeeDUBz81Rsxu42AF58EbiiLkoDDulSHd6S8gkpbJRg9OL3L//Ksl4XWeHOd5NFb/XYtUNdnfDHP2aKVK5SHGG0n7fU/BhCS8qvh4oHPRw8GFl8qVT0AairC+aM3PNLJm1V3njQR12du3BzM/v7+tLRfXUAK1ey+at+ZCls0ITNKt/UBFWJ3swaKs6SUpEaQ2jgRF4OO8mXMaYdeEVETnRN52ATEfqMurifPy1ohIqiKOOZcAX6oX6OAQq9y78Cvu8i+3YDn8AK349E5GrgZXIkLlSObsrKor/6y8szo+Y6OmCw6QRKFi8m+dRTAHYu5Ykn+PM/t3krb711EfDfeHfftm1wIFlP1SxrCXgLIMw56+eYvOVUV+esBW/C+IE5E+VAdwmptsyIuVzrqLKtd4Kh66r8MaF7MG5J+QjEuGXlt324ub8P/4eyD2X395pMwsKF7qLbtrGf6K/GBoBLLmHP37a5lgNYV58tItnURHTjQWz8wSD0XRkDqLsvLwU9HWPMdiBbwa1zCulXKQ5elLyLLFzYOnFiFBqeSkFLC5ywbBk1TqQOAIObNnHV3faYW289HStS1tu7Y8cBNm+u4oP+rewWACUSpDOlT51q53P8dkn3AUgFIdbJJAd6KuhotZv79tkxxYMSwnuJe1KGy+Hnf5aWRq46T1+fdSX6+0+lojVMqZQVJq8ZPT32WL/t+wqjxb0bc8UKd4E1G9mPrcsF0JRI8IuWucDPXEsvUM/kyTYwZeFCsorUQOrQM8ErRUTdfXlRCVey4udMIFoj5F+w3d2RSPkplZexs08ntP0CgPLyc+jrewg74Q+wlXXrzuGs2xcBbslvfz+V/QeY3xgoQnc3dASheckkvWU2jrC9HfbssUELMDSXn7eIwjVNYRYKGLqOKp4HMLxviBYHJ5OZc2WpVGQptbfbj1+43NMTVM4lun5nZ3S9ujo480yob/u1bfjZz+gmWGX2l3/JnXeC9aCDjeybx/LldqupCWhLZQy4t18X8o451JLKiz4dRVGUYqIiNSz6dJSchO6+ZHKoJcUlZ1G5YAEAlbt20Q7MveMOAG666Wxuvvlk4DHX21buu+8cVq60Wx+9uNF20tIyNNbd+8dqa9nfXeGKKUbWSjhF5ccH0ZxWaEmNJHdffC1U6JZ7++3MfgGqkoMkkyUZKY2SyShwce9eO86wqruf2/LjWbAALrgAuOk+AHb39NALnOQHcuON/Pi4A8BLrqEKODFtSdXX9kJLT0bKjWyh8spRjrr78qIipWTFh6FD9B4M51ba2uA16ql3qlOzaxetwFsPPQTAl9bBzTevxCYcAdiOMT9n3brzAFixopL67m546aVIQaqrrR/MxWXv7aygtRVefdXuTqUyF+kmEjase/Jku+2FIp6/D4amQgpD07MVSQzFrbs78/6TyRIqygapCrZ9KiR/Tn8/tLba7bYguKPBrXVuaoKqLT+Hb38bsFFHFUDt6acDcNdjc7GrOry7dAkiS9IiRVtbFH7uLnywSwVqzKHuvrzo01GGUF6e+RKPWydgLYVt2+BCJ1L13/42LYBPNXfqLV/mAx/4Ak89dZxr2QE8yUMPvR+Aa65JUF9bZs0O/2ZtbISGBnoTNkntqy1WoPxcj6/7FC6ijefQi/9RGq+am+slHg82iM9zdXVFYmivW5K+bkl/L9OnV2RYa93dpC3AVMoKVlmZvUWAZcuAmx7gt+7417FZmrnxRgC+9BmALUR1pJpYuRKWLnWbbe6hJJMMJuycnQ+aUKEaQ2jGibyoSCmKohQLtaTyok9HyUk4VRRaLGVl1lJ44QW48C9XAFC5cCGVzc0uUx+c+tWv8qVHvsBTT53qWnZgI9V+CcDGjefxwTV1Nm48LBiVSKQtp/j8k0+TFJ8Litd+ylUVN/yZK9w+PMYPyVtiPgS9q8tG+vnovmSyggrsPJUfV3V1NC6fFimZjDJM1Hf/HtaupcVfEzgB+P3SvwBgz56N2Ko3Pt5vCStWQH3SlezweZaSySEpoJQxhIpUXvTpKDnx8zI+ytmL1KRJ9h25dy/sTtUAMP/cc5nR3JzOgdXS1cX7+SWw2rU8iF3rsxWA9evP4zOfmUt9Y2M06eSUsCdIk1RWFomBf/lH4pDpKenvt5oXz9U3nAssW0BFvLRHX1/mvFVpqQ2D73RV0qZPh+rqkpyi7sW1ro5oTmn9elr6+nBTVdQBiSuu4JZb/FX+2/08zo1zkT3X+xCD+ah4cUVlDKGBE3lRkVLy4kXKi0N3d5RA1aXuY/6KFSz83vcocxECdQBdXZxyiv0H+NxzpwLb8ZZBQwPUl70O//mf8NxztpM5c6C1lfkXXwxAT+N8Nm+GTZvsbh9EEWaYCOebfH686dOjsc6cCbNmZWaxCPMB1tVBTfVgtDK3owO626HT3dgbb0QRG+FE1aRJkUk3a5aNhFi8GICdO0t44glYt87u3rVrD9DBrl0LWLnSPo8LF9oEvT5n/HyAs86i2wdD0uR+rrD/XeEu568JUFtLb6KKbjd0FamxyeDhZ6c7JlCRUvISTxXmQ627u+F//9d+P3PFcjj9dCo2bADs4t5FN97Izzb+KQB1dZ8BvoVPk/TUU1s57/LT+cxnfsDi22wfPT3Q3Awt66P+q6vhz/7Mbi9dCvWJ/fYgsFZF6A+cMMFGN4Qq5FKnH+i2L4J4MtjWVujqKuHNN+sB6Oiop6PjpPR+H0oeRhVWV1uRbXI6snQeLK2F+v5eAN7TlOI9n0+yZo0NaGhpmUV39yw7/i0/sSd95kb2E0nR/Msu4ye11/LQQztcy05s2UMb4r98ubtee6b/M1sRR2XsMDiY+bulDEVFSlEUpUgYo39Y5ENFShkRYWLWyZOjkhje4jiQrKdq5UoanCXVAuxvbmbmN23C2fvv/zJXXnkJ8APX471s2PAIGzYsBezaoCVLGvjYx+Av/9IeUbPxJ7B2LdyyEYDeffvoB8p89MEpp9hY7mUufeTixdDYyN59Jek8gz1t0N869H78NIBfluUDKAYGyCgf0t5u1xvv2AHPPGPb9u17HbuyyeVnYgCb/HUJAOeeO4Orr4aPnLsfgPrtD8C6dfRs2pQO0U8BNcB8N0nVe98PWNMI8Kw7ohxYxLx51j367nfbRcQZi9cSCfoDw0pfdmMPFan8qEgpecmWlcFH1rlpGKpSL0NHByVOQE744x/huuv45covA3Dl/2kD7sSmogX4CH/zNyv42iX/A7d9yja1t8ObK6FnDQAPl32IR6o/RKtbG5RMWpfXaafZ7dNPh/mNg1EwQU8PtLQwM5lkZp2NWhhMVpFKRaLja035ZLRvv233+dpQPrt5mCy2v99ey7sdFy6cwdKlM6hJ7bYNL7wAb++FBhuFsfe4M/jmN6HmehtU0tn5Z8DH+MQnpnHvTb+355x8Mlt6evitq2p40qqz2bjxFyxbZqvcdHVtAqJIx+efh9++q4STFjemBzZYVpH+/xH+1Jfe2MEYdfflQ0VKGUJoVUB2kUom7XRPumifj7E+5RS7nUjAsmXp86ZPb2DfvnOIamBWsW0b/Paq93DSNdfYpieesOrgslZceMEFNDXNZ+NGu7u52erYk0/a7eefh4aGEhoa5gJRtdpkIvjF7rb3E4/yDe8Noii/KVPsbcyebbcnT4Zp02xshM8WUdL2MrR2RG+XefNg4UJ+udnOez3yz/DYY2GC2Xmcey5ccw2kS+3W1bGotZUqf+GzzgIio/CppxYDfekIQZ91febMEvc8K9P/L0KRUoEaW7wTlpSIrAK+gc1SfLcx5rbY/gnAd4HTsO6BjxhjWt2+zwFXY90Ff22MeXy4PkVkHrAW6yh4FrjCGNNbyPg1rERRFKVIeJE63E8+RKQU+CZwAbAIuExEFsUOuxroNMY0AV8H/tGduwi4FHg3sAr4loiU5unzH4GvG2MWYEtzX13I8wG1pJQCSf9DieckcnmBFloDgYULYd++qfhy8rCHTZsGWL++lJNuWmWbOjpg+3ZXax4YGGDRWWfRcLldELx5s50b2rvX7vblMLy3Lyw3nytVkv/H7efX4vtLS214fbhguCrRay+2M8gYm0ikw/teTlWxeS1pi2/TJhv16C2cJUtg1Sp4T9PrcLc9aLC11ZaKnzbNHtTUREtLdC/QA5RmlEsJC1EOh7r9xg7vgLvvDKDFGLMbQETWAhcR1YDBbX/JfV8H3CEi4trXGmPeBl4SkRbXH9n6FJEXgLOBj7pj7nf9fruQG1CRUg6bvr4gAryxOlMd2tuhudlmVgBWrTqBTZtOBP7gTtiLzYy+nMZGO7fycbc+Kh1ibuPDqVpi39wfXLqUpUvnsnNndFiYlaK72152ypR4nr3M2lgTJkQv+8mTo0S1frsyMRj56lLd0VvEK1ddHS+3V7B9o93ctg22bo20dc+ezKq7F13kXH233wc/s0UMU0AC4E/+xB60ejVP3OKyywN24XNt2p06bZodYzwzhubqG9u8A+6+2cArwXYbcGauY4wx/SLyJjYSaDY2gWR4rnOEZ+1zGpAyxvRnOf6wKUikRORvgGsAg8178wlgFkfYJ6kUF/9i9C92vz0wEAlEb7KGisbGKINqKmUVxJkXl19+Aps2VfHYY0tcr88Cf+Cll6r46letp6C/v4arrvokJT/7T3vI88/bfrZts9utrdQffzz173oXAGedNZ/m5ijbeHu7DYAYGIgCIXyJjFCEysqstQRRZgivPyU9b9lqwJ5kEhoa2J8qSV+neTPs3ElaLFtb7bX9y2bOHBtQssoZiFddBRXf+SY88ADdbtFwBVC5dKndCTy6pYbNm8EYl8aCiUyePCk9DzZ9ejT2fKhojR2OwDqpWhHZFmzfZYy5K9iWLOeY2HauY3K1Z5smGu74gjhskRKR2cBfA4uMMQdF5EdY/+UHsT7JtSJyJ9YnWZC5pyiKMh45ApZUhzFm2TD724A5wXYDpFNsxo9pE5EyYAqwP8+52do7gGoRKXPWVLZrHTKFuvvKgIki0gdUYtMJHHGfpFJ8wr/gfRSZt1LAGk31DQ1w3HFRQyqV9l/N7XiW668/lb17TwR8JqQXgT+wY4c1a/7pn+bR3g6XXGKzVJywZImdo/ImTFdXxnblrFmc2tjIqSsaAdhPTbowYlhwMBx/tlIePT1ReieoZGCgMm0hdnTAK6/YS/rsGt5y8tcA647zRuQpp8DKlXD2UrtOijvugx//GHbswF++bMkSuOYaXlt2IQD/cXPk5bRMpakp6rO2NvvcWlhSRRmbjLLluxVY4KLuXsUaEh+NHfMwcCXwNHAJ8AtjjBGRh4EfiMjXgHps+pNfYy2mIX26c55yfax1ff600Bs4bJEyxrwqIl/FZsA5CPwceIZR8EkqRwdxoYJIpFIpqG9ssCVnwea8C9MWbd/OhZcvpr3dzj/dcceJ7NgxCfsrYhcDNTcnuPPOWWlNOuecubzvfXOpX+b+GGtuthM+Xh3a2uz2Cy8AUDNrFjV1dbC4jsFqu0Zp375o4TFEL3e/TsonYff7/Ropn8qvvZ0hwnfwoHV9egHxKZJ8+PhZZ0FNy6/hDpeIb/Nmm3Swro4y56rk4ovh+utZZwsZ85vf+DHYWlpz5pT68lrAUJHy9zIwMDTDuzJ2GO20SG6OaQ3wODZc/F5jzPMi8mVgmzHmYeAe4HsuMGI/VnRwx/0IG2TRD9xgjBkAyNanu+RngbUicgvwnOu7IApx903FRn/Mw84D/xgbkhgnq09SRK4FrgWoq5t7uMNQRhEfAQeZ63FKS4e+GFMpONBfSZV/c+/bF9WogHSVxIsueg9gm9eta+Dpp2digygAennllQOsX29f1K2t9uW9bJnNq7d4cT0nrBgcWvI2NOcOHrSLit0k08zaWmio5a3+ivQ4w1P8dlgeJNzu7o7KyXvB8BnN/a0uXGjzCtZ0v2wbNm6z82jeNOrpsQc3NdlMsQCXXMJP1pekp9s6Ony2dPvQ/fTezJl2f7aM7ypOY593Yp2UMeZR4NFY2xeC7z3Ah3Oc+xXgKyPp07XvJooAPCIU4u5bCbxkjNkHICI/Ad7DCH2SbnLvLoBFi5YVPLmmKIoy1tCME/kpRKReBpaLSCXW3XcOsA044j5J5Z0lXj4eMi2p8vLIzRS6yTo6oMqbGx0d1s/m/WYAbW3MbLDWxqpV1nqurS1n+/YGvxtj+tJWzM6dUel1sMZJU1MJTU3zAWhomE/DcqjocamWQhMpFqtd5lIIeeswtELiVTgSiSCTBnZ7yhQbYWevG1k6ABXtL8P2lmigra12LEHIOrNnW3PrAx8A4JfbKtm+PbM8VFgry7v6/DWTyaHh5319mgF9rKO5+/JTyJzUr0RkHTaWuB/rf7wL+E+OsE9SOboIk816fPBBba1N11PV0BBVBQSrYm6BL8CiZXV0vbeCsrJIEFpaoKOjPKP6RldX9O7v7LSney+arw1VV2fdg7W1VemKuBnzNz2RdoWVdiFa1uX1xItzGKLuxcMLSGX/ASu+2wIfYbhgy8e1h1lsGxth6VKe3WnF0sd/+HFNmGCvE85zzZ4djSvbGin/h4IK1dhFRSo/BUX3GWO+CHwx1nzEfZJKcQkr9Pqf3pryHDyYaThVNTXYl7Y/KJz0AWhtZcmSExgYiN7ltbWZUXMHD9rT/fXLyzN0jlQqc42TX7gblm73FkgoquXlmYt7q6uHJBdPi1cyCRX9b7kLB9UW/WSVJ6xrHy9lXFfHYKNd0xWurUqloheUzxHoDdHGRl/xNxozRMd7K0pfcGMbrSeVH804oSiKUiTUksqPipSSlVzzUv6nt068oeSzT3hDKZksseumwj8Twzmj9nYqq6s5/vgZ6X+k3vgIy2QMtw7IWxfey+aDCbu7My2p0Kjx7d6d5y0nX23Yp0kq6XnLdd4T1ffw+ER6nvhiLG9JOTOoN1lDSzMZ2TE6XBJ1P55Jk2ymCp993bsy/f5wbZp/3vG0SPqyG3to4ER+VKSUEREPR/cvT7/eaGDAfg8jzpPJqiiQwr9B/b/Iri4bSNGUYKCpKqPvMPw7/uINtSE+L1ZePrTUvSd8kXtBCvsckrg1VIdEIvvETy5VcLVMDvTY+ae2Fjvf1tpql3VBJMTenVdba119c9w6/pkzM92W/nJetNXVNz5QSyo/KlJKTvyLeziLKv5yD0UqkYBEo60sW9Hg/iX61A4DA+kU5vU+WqCpMkMAvbURr2UVt+jiRf9KSzPzDIZ9ZhOv8Bp9fX5dlE9PVmEjA2PXKWFwqFi5AwbLKjKys7e2Rh9fMRgy59N8tKDX9KlTrZiG4+3rG1rjS8VqbKMilR8VKWXExC2XuMXS1xcJmnf9+f0NDfVU+JMgihoI3ub1DQ2UHl+ZEdQQVtXN5VULAytyCddw1Wv9Yl3fHs+s4UUvtGrKykooCTodpCRaU9xuLaZXX7Xbra3RuuPQtVldHYlSQ0Pk4gMrYOEfAD6aL8ycoYx91N2XHxUpRVGUIqGWVH5UpJS8ZAuigEw3mv9rMJwzSaUyw9fr6uqpCE0aP+kUZGqdWVfHRDdHlUhk5syLR33764TjzEY8pVM2hpv78hZanN7+kvS5XV2RK6+93VpOYf4/b0X55+XXXsUtqXiARziVFw+SUFff2EdFKj8qUsohk+1FH3+Je7EK52AA6urcHJWPkAijI1zVwqpau93UVEN1dfSy966/MFgj2zULGX/cXZjtWC8YYbaNzk6bUxfsePfti7a9yIZzUNOmwaxZ0ULm2lq7Lx7UEQ+U0Ei+8YWuk8qPipQyIuLWVPzlnUhk/8eWy/Kpq6uhsiGRmanBv/ndW72iv5/6ulqSSWuxeKvKH+4jw+OBFUcaP9cWBi10d0eFFd98M1Ok4klsS0uHFlf0809+DsoLVGgN9vXZDO3+mppdYnyi/x+HR0VKURSlSKgllR8VKWXExEPSs0X7hYR/+WezqGprK6lpaBg66RS6/4AqN1GTbKxMWyl+t68H5fv0P7PVvhoJ2dxp8QKPPT3RomGILKfQwgvnn7wVFbecamuHzkGF1urbbw+dg4qPUxnb6JxUflSklCOCD6LI5d4LX/IQZlEvodoVKKxMJjOjI2InlfT3U1OdTLv/4in0vDiEL3rvossXMBF/UYTrpnzody6R6urKFBTIzC/r3XxhlvN4Dlo/vmzroLJtK+MDFan8qEgph0w4PxW+XMNov7goecI2f4xvmzSpgqlTa6hI9kYHx9/U3d1UuItUV1dkCGM4RxUXn1wvgnBtl7+P+Pk9PZkWW3wuzN97GGzh0yvZcdrPpEm2HbInvo1X2c0mUsr4QtdJ5UdFSlEUpUioJZUfFSnlsMgW7ectCk+Y8i5uCYQWj++np8daK8lkhTu/gkQSSvp7o04CShgkkSjJCB/348hnkWSznsL9cY9jvM1fD4bOK/mEtmG5D+/ai6dnCsPo1b137KGBE/lRkVIOm1xCBfmDFeJiAFag/HwP2Bf7hAkwcWKF67NiSCqmePj5xInROqr49bKRy70XzkmF/We7t7KyzPDxbJnXfeL04RLfZguOUJEa36gllR8VKaUg8kX8hfhyE3HCiu9hVJwvZRFaH/G1RLkEK9u18x2TrU9PaWnmQtswC4WfiwuDICZOzBx3LnHNJ1LK+Ef/Pw9PXpESkXuB1cDrxpjFrq0G+CHQCLQCf2GM6RQRAb4BfBB4C7jKGPPs6AxdURRlbKPuvvyMxJK6D7gD+G7QdhPwpDHmNhG5yW1/FrgAWOA+ZwLfdj+VcU62/H7xGlTZ/mLMZjnE54PiFklmNvLhr3GoczvZXHnh9cJxxC2psAT9cK69cFzDbSvjH3X35SevSBljfikijbHmi4AV7vv9wEasSF0EfNcYY4AtIlItIrOMMXuO1ICVo5fhhCoeVJFLtGDootwwUKG0NNM9mG/Rbr4Q9DABbnjNbMTz+cVrVsXz/+UbR7bv+sI6tlCRys/hzknN9MJjjNkjIjNc+2zgleC4NtemInWMEM8958k1VxUXq1yLav33srLMiLiwwGHYZ5x4v+FcWji2XOOMz4PFxXE4qynczidSyrGFrpPKz5EOnJAsbSbrgSLXAtcC1NXNPcLDUBRFOfpRSyo/hytSe70bT0RmAa+79jZgTnBcA/Batg6MMXcBdwEsWrQsq5ApY5tDcf+NlGwWStyyCq+Zq8bUSPfncieOJMQ+2/ZwlqJy7KGBE/kpOczzHgaudN+vBH4atH9cLMuBN3U+6timvDy7EJSWZs4HDffJRxh0MDCQKVo+7VH4GY5s1x7p3NdIPtnGrBzbjPR3Z7jfp8NBRGpEZIOI7HI/p+Y47kp3zC4RuTJoP01EdohIi4j8i4vuztmviHxMRH7rPv8jIiePZJx5RUpEHgSeBk4UkTYRuRq4DThXRHYB57ptgEeB3UAL8B3gUyMZhDL+ySdW/jOcSIxUtGCoWOUjV9+FCFKubBcqTorHu/uKIVJEUdoLgCfddgZuudEXsVHaZwBfDMTs29gpGx/RvSpPvy8B/8cYcxJwM86Tlo+RRPddlmPXOVmONcANI7mwcmySK7DCE0+4OhpFDA+FMLIw3zGHu185dimyuy9XlHbI+cAGY8x+ABHZAKwSkY1AlTHmadf+XeBi4Ge5+jXG/E/Q7xbsdFBeNOOEoihKkShy4ESuKO2QXBHbs933ePtI+70aK2h5UZFSikY8pVKcXOHg+dx4w6VmykU+i+lQXiRqOSkj5QiEoNeKyLZg+y4XlAaAiDwB1GU57x9G2H+uiO0RR3IP6VDkA1iROmskx6tIKUUnnwswzuGI0EiJC8xI1lwpSiEYM1jI6R3GmGW5+zYrc+0TkVxR2iFtRK47sC66ja69IdbuI7lz9isiJwF3AxcYY94Y9s4chxvdpyijgg+wyBVocST6PxRGYbJaUQIMMFDApyByRWmHPA6cJyJTXcDEecDjzp3XJSLLXVTfx8mM8h7Sr4jMBX4CXGGM+f1IB6mWlKIoStEwQG+xLn4b8CMXsf0y8GEAEVkGXGeMucYYs19Ebga2unO+7IMogOuxuV0nYueXfjZcv8AXgGnAt1y0ev9wVqBHbEBecVm0aJl54IFt+Q9UlICRuAZHwxpTlEI47TR5xr+cRU418F8F9Fb1zEhe9GMZtVpVBRwAAAjTSURBVKSUMYsKkDL2GaSIltSYQEVKURSlqBQ8tzSuUZFSFEUpGj5wQsmFipSiKErRMMAIJlePYVSkFEVRioZaUvlQkVIURSkqKlLDoSKlKIpSNNTdlw8VKUVRlKKh7r58qEgpiqIUjaJmnBgTqEgpiqIUDbWk8qEipSiKUlQKyoI+7hlJ+fh7ReR1EdkZtP2TiDS7WvUPiUh1sO9zrub9iyJy/mgNXFEUZezj3X2H+xn/jKRUx31Etes9G4DFrlb974HPAYjIIuBS4N3unG+JyChW/1EURRnLFLVUx5ggr0gZY34J7I+1/dwY4yvrhLXqLwLWGmPeNsa8BLQAZxzB8SqKoowjfAj64X7GP0diTuqTwA/d99lY0fKEde8VRVGUIRwbFtHhUpBIicg/AP3A931TlsOyFqwSkWuBawHq6uYWMgxFUZQxikb35eOwRUpErgRWA+eYqHJiGzAnOCyse5+BMeYu4C6wRQ8PdxyKoihjF804kY+RBE4MQURWAZ8FLjTGvBXsehi4VEQmiMg8YAHw68KHqSiKMh7RwIl85LWkRORBYAVQKyJtwBex0XwTgA2uVv0WY8x1xpjnReRHwO+wbsAbjDHHxpNUFEU5LPQVORx5RcoYc1mW5nuGOf4rwFcKGZSiKMqxgaZFyodmnFAURSkaBs04MTwqUoqiKEVDLal8qEgpiqIUDQ1Bz4eKlKIoSlFRkRoOFSlFUZSioeuk8qEipSiKUjTU3ZcPFSlFUZSioYET+TisjBOKoijKkaB4GSdEpEZENojILvdzao7jrnTH7HLp8Hz7aSKyw9UP/BdxmR3y9Ssip4vIgIhcMpJxqkgpiqIUlcECPgVxE/CkMWYB8KTbzkBEarBZhs7Ell36YiA638YmCV/gPr7uYM5+XX3BfwQeH+kgVaQURVGKRlEr814E3O++3w9cnOWY84ENxpj9xphObMHbVSIyC6gyxjztEox/Nzh/uH7/Cvh34PWRDlLnpBRFUYpGUQMnZhpj9gAYY/aIyIwsx8wGXgm2fY3A2e57vD1nvyIyG/hz4Gzg9JEOUkVKURSlaBQcgl4rItuC7btcGSQAROQJoC7Lef8wwv5z1Qgcce3AgNuBzxpjBtz01YhQkVIURSkaBVtSHcaYZTl7N2Zlrn0isldEZjlrZxbZXXBt2CoYngZgo2tviLX72oG5+l0GrHUCVQt8UET6jTHrh7tBnZNSFEUpKkWrJ/Uw4KP1rgR+muWYx4HzRGSqC5g4D3jcufO6RGS5i+r7eHB+1n6NMfOMMY3GmEZgHfCpfAIFKlKKoihFxLv7DvdTELcB54rILuBct42ILBORuwGMMfuBm4Gt7vNl1wZwPXA30AL8L/Cz4fo9XNTdpyiKUjSKFzhhjHkDOCdL+zbgmmD7XuDeHMctHmm/sWOuGuk4VaQURVGKiqZFGg4VKUVRlKIxiKZFGp68c1Iicq+IvC4iO7Psu1FEjIjUum1x6TFaROS3InLqaAxaURRl/FC0wIkxwUgCJ+4jSneRRkTmYCfFXg6aLyBKkXEtNm2GoiiKkpWiBk6MCfKKlDHml8D+LLu+DvwdmQu4LgK+ayxbgGoXJ68oiqIMoXgJZscKhxWCLiIXAq8aY34T25UrhUa2Pq4VkW0isq2zc9/hDENRFGWMoyKVj0MOnBCRSmxKjfOy7c7SljVVhkvdcZfrc99pp8kfgY5DHc84oxZ9BqDPAfQZeMbjczgu+vrm4/DT2gL6Gm/PZgiHE913PDAP+I1Lb9EAPCsiZ2AtpznBsWGqjJwYY6aLyLbh0nscC+gzsOhz0GfgGe/PwRgzZL5fyeSQ3X3GmB3GmBlBeos24FRjTDs2HcbHXZTfcuBNnw1XURRFUQ6VkYSgPwg8DZwoIm0icvUwhz8K7MamyfgO8KkjMkpFURTlmCSvu88Yc1me/Y3BdwPccJhjuSv/IeMefQYWfQ76DDz6HI5xxOqKoiiKohx9aBZ0RVEU5ail6CIlIqtE5EWXSummYo/nnUREWkVkh4hs99U1RaRGRDaIyC73c2qxx3kkyZZmK9c9j+c0Wzmew5dE5FX3+7BdRD4Y7Pucew4visj5xRn1kUVE5ojIUyLygog8LyKfdu3H3O+DkpuiipSIlALfxKZTWgRcJiKLijmmIvABY8zSIMz2JuBJY8wC4Em3PZ64j6FptnLd83hOs3UfWdKNAV93vw9LjTGPArh/E5cC73bnfMv92xnr9AN/a4x5F7AcuMHd67H4+6DkoNiW1BlAizFmtzGmF1iLTa10LHMRcL/7fj9wcRHHcsTJkWYr1z2P2zRbw6Qby8ZFwFpjzNvGmJew0bNnjNrg3iGMMXuMMc+6713AC9gMNcfc74OSm2KL1IjTKI1TDPBzEXlGRK51bTP92jL3c0bRRvfOkeuej8XfjzXOlXVv4Ood989BRBqBU4Bfob8PSkCxRWrEaZTGKe81xpyKdWPcICLvL/aAjjKOtd+Pb2MzuiwF9gD/7NrH9XMQkSTw78BnjDEHhjs0S9u4eQ5KdootUoeVRmm8YIx5zf18HXgI68LZ610Y7ufrxRvhO0auez6mfj+MMXuNMQPGmEHsYnjv0hu3z0FEyrEC9X1jzE9cs/4+KGmKLVJbgQUiMk9EKrCTww8XeUzvCCIySUQm++/YhL07sfd/pTvsSuCnxRnhO0quez6m0mzF5lf+HPv7APY5XCoiE0RkHjZw4Nfv9PiONGKTf94DvGCM+VqwS38flDRFLR9vjOkXkTXA40ApcK8x5vlijukdZCbwkEvSWwb8wBjzmIhsBX7k0k+9DHy4iGM84rg0WyuAWhFpA74I3Eb2e34U+CA2UOAt4BPv+IBHiRzPYYWILMW6sFqB/wtgjHleRH4E/A4bEXeDMWY81Gl4L3AFsENEtru2v+cY/H1QcqMZJxRFUZSjlmK7+xRFURQlJypSiqIoylGLipSiKIpy1KIipSiKohy1qEgpiqIoRy0qUoqiKMpRi4qUoiiKctSiIqUoiqIctfz/Q71px2FpMooAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAADbCAYAAADXsW4lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvX94VNW56P9ZYRiGMMQhDGSAgCMNGGnUaEFR0Yv1R7H1aLVYf9Se2qv12tse67mH89We9lar9mhveartqUcfa6tWWrBQa5EqKhZaaaUFKwpK1FRHiTKYQEYIMCQh6/vHu9bsNZNMEgkxBNfneebJrD17r732yp79zvtjva/SWuPxeDwez8FIyUAPwOPxeDyeYngh5fF4PJ6DFi+kPB6Px3PQ4oWUx+PxeA5avJDyeDwez0GLF1Iej8fjOWjpNyGllJqjlHpVKVWvlLqhv87j8Xg8nkMX1R/rpJRSQ4DXgLOABmAtcKnW+pUDfjKPx+PxHLL0lyZ1AlCvtX5Da90KLALO76dzeTwej+cQJdRP/U4ANjvtBuDEYjuPHh3XkyYl+2koHo/Hc/Cwfv3zTVrrMQBVSundfehrCzyptZ5zgIZ2UNJfQkp1sS3PrqiUuhq4GmDixEn88Y/r+mkoHo/Hc/Bw2GHqLft+D/DVPvT1HYj3fUQHN/1l7msAJjrtSuBddwet9b1a6+la6+mjR4/pp2F4PB7PwU1JH14fBfrrOtcCU5RSRyilwsAlwNJ+OpfH4/EMShReSPVEv5j7tNbtSqmvA08CQ4Cfa61f7o9zeTwez2Cmv3wuhwr9Nj9a68eBx/urf4/H4xnsWE3KUxwvxD0ej2cA8UKqe/z8eDwezwChEE1hf1+9OkcP2X+UUsOUUg+bz/+qlEo6n33TbH9VKfWpnvpUSp2hlPq7Umq9Umq1Uqrqg8xHV3gh5fF4PAOI6sOrx74l+89dwDnANOBSpdS0gt2uBJq11lXAHcD3zbHTkKC3jwNzgP9WSg3poc+7gS9orWuBXwHf/kCT0QVeSHk8Hs8AoYChfXj1gt5k/zkfeNC8XwKcoZRSZvsirfVerfWbQL3pr7s+NVBm3h9GwdKj/cH7pDwej2eAOACBE3GllJsJ4V6t9b1OuzfZf3L7mMjs94HRZvuagmMnmPfF+rwKeFwptQfYAcz8wFdUgBdSHo/HM4D0UUg1aa2nd/N5j9l/utmn2Pauhmz7/Ffg01rrvyql/h34ISK49hsvpDwej2eAsIET/UiP2X+cfRqUUiHETLe9h2M7bVdKjQGO1Vr/1Wx/GFje1wvwPimPx+MZQPo540Rvsv8sBb5k3s8F/qClhtNS4BIT/XcEMAX4Wzd9NgOHKaWmmr7OAjb1eiKK4DUpj8fjGSD6W5Mqlv1HKXUzsE5rvRT4GfCQUqoe0aAuMce+rJT6NfAK0A58TWu9D6BYRiGl1FeA3yilOhCh9T/7eg39UvTwg3LccdO1z4Lu8Xg+Chx2mHre+pE+ppT+zz70dQk834NPatDjNSmPx+MZQLzPpXu8kPIMetrbi3/W1rZ/fQ7tZhFKyH9rPAeIDyFwYtDj58czaCgURm1tsG9f/ud2n8K/xfqwFAoe23b/uvsMGdJZkHnh5dkfvCbVPf5r5fF4PAOEQiIPPMXxQspz0GK1Hmuy27cvX1vKZuX9nj2dP3c1qe7MgV3hak32fSgk2hPA8OHSjkTy97GfWw3La1ae3uCFVPf4r5HnoKK9PV8oWUEE0NIi7WxW2va9bRcTSMVMee45u2vbY+xxkUjwctvRaLBvJJIvtLzA8nSFryfVM/6r4xlwXI1p7958IdTSIi8I3hcKJVfrscLCCoxotLMAcQVOoeZl++/qnK52Vii0Cs9pz2s/HzbMCytPZ3zgRM/4+fF4PJ4BxGtS3bPfQkopNRH4BZAAOpDsuz9SSpUjOZuSQAr4vNa6ue9D9RxqWNOejdCzWovVYjIZedm21aBcDSaRgHhc2pWV8gpn3oN0Wjam01Cflo4Adu4Udc1l2DAYOVLex2LSaSIh7USC1thYGhqgoUE2NTXJy46npUXaVnOKRqWbWCxo25c3AXoK8UKqe/ryNWkH/k1r/Xel1EjgeaXU08AVwDNa69tNxcYbgOv7PlTPoYDr77H+pEKhZOVJJhMERYDIkdGjIZmU9pQpUJ59F154QTYseRk2boTXX4d//EPO19jIbsDIE1qRX1Qdpm1zoIVNOwKUAqExY2TDxz5GeMoUJtfUMPnjH5dtM49je2Q8r78uzVQKtm0T+QfyN5MJhJQVWLFYYBJ0fVrgBdZHFR/d1zP7/dXQWm8Btpj3O5VSm5BaI+cDs81uDwKr8ELKQ35QxN69Ipx27pQHPIg20pVgskKpuhomx7bD6tWy4eFVsHo1HWvXAvAeknhsB/lCqZ1AKPVECfKlCDc2AhBpbKRszRrKgbF2nxkzKJ81ixNnzwbgxLNm8UamnLo6+TyVkuuy12EFVjwuQtZeVzQqSpzFC6qPHl5I9cwB+VoopZLAccBfgQojwNBab1FKjS1yzNXA1QATJ046EMPweDyeQYf/bdI9fU4wq5SKAn8Evqe1fkQpldFax5zPm7XWo7rrwyeYPfSxWtSuXdJuaRENw/p3AJqN59K6h5JJqK2F8S2vyYZly2DZMjpWrgTgbUR7MtZBWs3fEGK2AzHdRZ12xHxu/QAdiKZlNa8s0ALsdtrWQmlNgjFEq7I/rUpOPx3OPVdewLvRqaxfLxoVBGbAUaMC/1k8nm/+GzHC+6k+KrgJZqcppR/qQ1/Te5FgVik1B/gRorTdp7W+veDzYUh8wSeAbcDFWuuU+eybwJXAPuBarfWT3fVpys7fClxkjrlba/3jPlxi34S4Umoo8Bvgl1rrR8zmrUqpcUaLGoc8RzwfUdyFt9ls4G9qapKYBjcwIhKBCRNgxgxpT25/De5fDA8/DMD2DRtIAUamkUVuYPOcZxISxRNLJOCkk2RjbS3U1AQ2w8pKkQ5uDHomE0RFpFLi11q/XtrPPUcmnSZNcCM3AWnAiE7iK1eSXLmS8gceAGD8xRcz/qKLeKNayuqsXQvvvNM52MIN+rDX7y4Q9nw06M/ACaXUEOAupLZTA7BWKbVUa/2Ks9uVQLPWukopdQnwfeBipdQ0pGzHx4HxwAqnVlSxPq9ACiJWa607ilnSPgh9ie5TSB2STVrrHzof2QJat5u/v+vTCD2Dlvb2/IdyczNs3SrtpiYwbp/cg7qmBk6u2QEPmd+WDz5I09q1vGH6ew/RfKxQqgamAlx0kWy4/HJa55zHI8vg6adl018fhY23QlubcXyxA9hKfuhEFDgcgKFDj6em5kJOPFE+PesuUZCqly+lesEC2bh4Ma8h307M33eBsRs2ADB5wwbiv/sdk78kdeQmf/GL/GVjGRs3Btrinj3589PWJpqWJRLxguqjwIewTuoEoF5r/QaAUmoREjfgCqnzgZvM+yXAT8zz/XxgkdZ6L/CmqTd1gtmvWJ9fBS7TWncAaK37rKT0ZX5OAb4IbFBKmZ+d/AcinH6tlLoSschc1LchegYj9gFstSSrOdnIcGsCSybh1FPl/fj6P8E195BduBCAjYjGYsVJOSKUxtoD5s3jterzuOMOaf7ycti5cwPyXXnbHNVE51AKJystIBYLMea1tUV44YUyXnhBJOc990wCpjFy5Hl84QvnAfCvr8LUuqVMnT8fgPeefZbXzFhBhGli7VpqTEBH5M9/5uRrriF57mk8+6zsk0qJkHYXJu8rGJYXVB8NVN8OjyulXF/JvVrre532BGCz024ATizoI7ePKZL4PjDabF9TcOwE875Ynx9DtLALgEbERPj6B74qh75E962m+Pyesb/9ejwez0cFBXRTFaY3NPXgk+rqGV0YiFBsn2Lbu7JQ2j6HAVmt9XSl1IXAz4FTuxlfj/jfaZ4DiuuDctc8WS3KtiMRMe+dfWYH3H23bJw/n/pUKmfe241oT9NMO37RRTB/Pj9+VEIWbroCmpv/DKw1e7yJaE6tBIG9w5FwiZjTHup8vg9oA2zcexbRhd4y7b8BYXbujHPPPUcAcM89Mxg16jxuukk0q2sXvM3YefNoWrwYED2uAQmHB5i8cCFVzz3H+HnzuPirXwXgqRUlbNwYzEdX8xiLeR/Voc6HkLuvAfERWSoR63RX+zQopULAYcjt292xxbY3IHEKAL8F7u/j+L2Q8hw4Cn1QmQxsNkaBrVtlm41mmz4dTq58G66bT+t//RcAf0dMZjYS7xhg8umngwlI+M59k7jl8F3AQrPH88hSPWsnGwFMRr4zlWZbJTAOsV7AqFFDiEbz4ybEX2b72Gb6dD1O1utkLR9raW7+Ld/4xicA+MY3zuP//t9fc/NbYmI87YoreGPlylxgxUagKZXi+K9/nfCrrwJw9rx5RKOTWGcMNZlM/joyyBdM3vR36NLPQmotMEUpdQTwDhIIcVnBPjaO4DlgLvAHrbVWSi0FfqWU+iESODEF+dWmuunzUeCTiAb1Pwjii/Ybf9t7DgjFfFA2UKKlRTSDmTOlfXzoJZh3K+8tXsxLpo8dSHTeybbWxYIF/CL7eb50uBUgCxBBYeP7hiNCyepaxzJ06DRmzRIhCEFgn81yFI/nP/DtuJuaRLNKp8eSSo1l48ZjAVi3TtYOt7W9ArxozmN1JRsT9GduuWUmt9xyKQAPPvgH/vmaXzP58ssB+EtbG+8ioe3HGIE8Np3m5G9/m8isYwBYsyZfq+qqMrAXVIce/R04YXxMXweeRMwHP9dav6yUuhlYp7VeigTAPWQCI7YjQgez36+RG74d+JrWeh9AV32aU94O/FIp9a/ILX9VX6/B3/Iej8czgPR37j6t9ePA4wXbvuO8z1IkwE1r/T3ge73p02zPAJ/p45Dz6PNi3gOBX8w7eHHLbOzaFYSVv/NOvg8qFoNZs+CY7N9kww03kFq5MvcTDSRyr/qcc2h9VO792bPhueeeAp4yezQgJr1q056JUqcyd6605syRc0yt3A319bJx82YZhF1FbGtu2IHbmhvW+TNihAx2ojG5V1XxWkMpq1fD8uWyackS0PpZAvNfHbCLwMR4NieddDarVkkr/NlPU/fEE7xG8KtwGpA8/XS4XdZVvhQ5gdWr8+crkZB1YwBjxgQLfu2wPYMTdzHvMUrpTk/6D8DEXizmHex4IeXZb1wfyq5d+WtiGxqkbX1Qs2bB8e1/g3nzAKh/9lleQR7ax5v+Et/9Lo/UfIfPfW6H2fJTxMRmgxyOBGYzZozYDK+6CubOheOTJkTBpnloauqcOv2D4qY0j8eD9BfA31PlLFkC990nuzQ2rkFSVL5qDt4HHAt8BYDf/KaMCzfeTPrGG/m72aMdEVRVNpx+/nz+Hjohl5bQmkcrjdyza5BHjJC2z04xeHGF1LFK6ad6OqAbEl5IfTh4ITU4sUEHIAIpnQ6EVGOjPEitD+rk6Etw3XXUm5RGryArk04GykxGif9Y/3luu20tUukFJIBhHHAaAEOHnsd114lwApgaekOcRjb/kI0+cCsSDhsW1HsHqZVR6PBx64XYevS2nIdbWdGmNU8mYfp0XmufDIiwuvNOaGtbajr8kzN2gIv55jdn8J+1v2bHxRcD8BckBtF606pOPx3uvJO/tAQ+qrY20aBAhFQikV/+wwupwYkrpGqV0k/3oa+xHwEh5W9zj8fjGSB8Zd6e8fPj2S8Ko/msJmV9UmDSHFWazA/zbs35oEC0qNOA0mee4bL7PgnAwoW/B5Yh/h2AWuAC/umfqqSLeXBa1btgtDFSqcDXBPl13K1dbOTIrpPiueF97l+bZNCmxNi1K6jEaB1G69fD668z1eQD/H/Xnc65545n/nxZN/XYY9OQJSIbzMB+zm23vUfq0s/zq2ckk8VpZ5zBnwhy04RWriR5662cbLJYtNRM4oUXgvm0bjN3+D7a79DAFz3sHn+Lez4w1hflPsttLShLMmkW6l5nUgctXpzzQYGY+UqfeYbz7vwkjz22xGx9wvy1CUsu47vfHWrdWJSufgoWrM8/kQ10ALGN2dTihdUFC4VTVxdl/1pBBfkCykoMG4jxsom6fecdTqutZfqiswGYP7+KG2+8DviV6fxPwCMsXLiHlhaJ8lj6zDOcfMYZGBcUrwClixcz1sTKn33nnTQ3l+RZMpuagvpTkUhQ5dcLqsHLh7CYd9Djb2/PfmGLFroFC1tagmSxp54K3H13bqHuS0iwgM1OWfbww1x2nxVQvzdbhwJnM26cPMjnz4fLZr8LS1bIx/X1IkSslhSLwbhxwUldAeXWmHef4j0JKfveTapnBZVdbNXUBFu25JcQXr2aUpOY8DtXnUlV1XjmzZMEs1u2jEAiFH/PY4/JIZdF5/Krhx/meOOj+puZo9PMfIWPPJJTL/ga778fnNItUW/dbF2tp/IMLvxDuHv8/Hg8Hs8A4TWpnvFCytNr3DVRhbn5mpuDfHxgMprPn58Lud6BRLIlvvtdQCL5xAf1BEGKzXOprj6Pu+6S1ifjL8GSVUHq9FBItBk3fYStHgiiQRnzXofz1XeVJNz3eYRz70KRMERKASihQ/rNZoPzxGLystUa02l5b+vHZzJcNns2iQUSqfe1r82lri6M+NvEpLlw4XCSyc/zn9+VY6beeCOvQG6+Zs6fz/ijj6amRiIb16yRObZWTHupvvz84MYHTvSMnx/PB8aa+qyfxDJhgqkHBXDNPdSnUrnyFQlkoe4jNbLQ/bbPrUUe2gDiy6muPo+f/QxODpkFv8tXyUmsjcuubh1nQrvj8Xz/UyhEByV5a3X3B/fYUKiEUKSUEhuUAfLXCioQ82MkEgjTdBqWL+eTs8Vk+LOfncCVV55HXV0rgd9tGbfdNpbpv5H5uPCcNWx/4oncfNWnUlTdcw8n3yNrszZvLsstAbNDsILKm/wGN16T6h4vpDy9wnXTuFrUHpM8fORIU1HXFCzMLlzIGwTJYk8eOpTWRx/nc8PsQt2HkSi+M3I+qLvuMgLKpmrIZEQA2OwPdrGQ9UGZp3Rru/maFxFOH1RguRpJsEyqBKtthW16cis8IxFxEtm2zXJhruPk2XDXXSdw+eVz2bLFRiM+AzzM5z53JAB79z7OydEwy83q6DeAyoULiZxyCgAzzvka27YFgSp2oXR37jfP4EDqC+4nB8E61/7G39Iej8czUCgV/LjZH+yvxEMYL6Q8vcZqJNbUVxhyPrn9NXjwQUDKU+xGym0AsGABs2eDpDoCychQC1yGWRokPihr4gMxp02YAEdIHadcygVjdusIhbs07fXF1NfV8aFQ4TZjAixctGQfNkOGSPJCex2rVvHJORHmzz+GL3zBVjR4D1iPnY/Zs/+NvyxYwFQT7fcSMofTzXxOPussksmpmAr1OU3KrTnlGYQo1e/qr1JqDvAjJL/YfVrr2ws+Hwb8AvgEUqvmYq11ynz2TeBKJNfXtVrrJ3vZ538BX9ZaR/s6/j7PjlJqCLAOeEdrfa6pMbIIqVf3d+CLWuvWvp7HM3C466IgiMjeswdGjZJttbXA/YtpMiXT08gNMPn00wH4RfbzJlmsLXcxDriA7353qISZgwRJWBMfBALKDZSIRnPmvfaCtHx9FU7FcHPR2raYAB3zX1cPGpvY0Jj+Lpsbp/674wG48cYLgK3Y+Xjuuaf4xTWf559PvweAhpUrSUNuPuOLF1P75W/l0k41Nwf/B+sqs0EU3uQ3iCgp6duvDGv/LYJ5Pt8FnIVkaF6rlFqqtX7F2e1KoFlrXaWUugT4PlICfhpStuPjSD2pFUqpqeaYon0qpaYTVBntMwfidv4GsAkoM+3vA3dorRcppe5BJuDuA3AezwCyd28gpDKZINOETYA6vuU1ePhhTO5xOjB56UzBQqkJ9RRBstjT+Kd/qpKFunYdVDotX1jrg7ICyvFBtbaXdFrS9GGRH1DhtksIR7v4wWjzAaZScm0rVjBv3j8DsG5dFY89dhqSmQLgKb70pTP457ceAGDa4YfzF8jNZ/zhhxl/0UVUVsozwgqpTCaI3/BBFIOQ/tekTgDqtdZvyOnUIuB8gmQnmPZN5v0S4CdKHGXnA4u01nuBN029KbvUscs+jVD8AVIE8YIDcQF9mh2lVCVSO+R7wP8xF/ZJgiqNDyIX74XUIKatLT+ZbEuLCKyRI6HaVs14dBnbN2zIlSMsR8q9f+e+SWbLAuRHl0SrDR16HvPmmSwStqyGDTG3ks8KKCMABlJAFWJzzgbj6EJQuZEmDQ1QXy/XC8ybdzbLl59niimCmP4W8p37pFDizRddRPnixbn53L5hA+XLllH92f8DiNyzaans/yUalf+V16QGGX37h8WVUm527nu11vc67QnAZqfdAJxY0EduH1Mk8X2klPUEgno09lhTPKZon18Hlmqtt/QpIMShr7fzncD/B4w07dFARmttHx/uReWhlLoauBpg4sRJXe3i8Xg8hzZ9NfdBUw9Z0LuSFIUhgcX2Kba9q6h5rZQajxRPnN3NeD4w+y2klFLnAu9prZ9XSs22m7vYtcsYSSPt7wUp1bG/4/D0H1ZT2bcvP5lsS4v8Yp8wASZH35ONy5aRQsx8IAUMmT+fWw63IddrkIKFswG47jqTLHbB+uBEdh2U9UGZIImcD6ogF+xA4/qqrDYFiEbV3h5cx549MoHptCSnBU67vIbrrhvPD34w2/T2OrCGW24RC8nNb81n6uLFuZ+xKaB82bJcSfrRo8eSSuVrUtmsPO8KfWieg5j+N/c1ABOddiXwbpF9GpRSIeAwpIx8d8d2tf04oAqoN1pUqVKqXmtd1ZcL6MvsnAKcp5T6NLIcpgzRrGJKqZDRprqaEM8gozDjeTYrvo9kEmyVvo6VK2kCrMFr7Kmn8uNHJwELzZYm4BN5BQtZuTI/UCKRyM/FN8A+qN5iTX+dfFT2OrJZSUi7c2cQ8bdyJVdd9QUeeEDmo7HxWeB5QGpS/fjRS7n21FOJPvssILPXsXIlJWa+k8kLeeedzv+Xg3F+PN3Q/0JqLTDFBLS9gwRCXFawz1LgS8BzwFzgD1prrZRaCvxKKfVDJHBiCpJmUnXVp9b6ZWTdvrk01dJXAQV9EFJa628C3zSDmQ3M01p/QSm1GLnQRciF/66vg/QMDDY4rVBI2ai+o44CHpaH5ttAlqCwO/PmcdMVIA9egOHAzPyChTbFt/X82zRHboi5E8F3MD+AC31UoUiYEuujiseDLOq2tEgqxdST3uCqq6Rw4m23zUR82TJfN910Kdc+MI9KI6TqkDlOGiF11E0X8uKLQQAFBELK/t+8JjUI6Os6qR4wPqavA08iUUs/11q/rJS6GVintV4K/Ax4yARGbEeEDma/XyM3ZjvwNa31Phl25z776xr64za+HliklLoVeAGZAI/H4/EU8iGsk9JaPw48XrDtO877LOJL6urY7yGBcT322cU+fV4jBQdISGmtVwGrzPs3CMIUPYOU9vYggtpqUVlHq4nHoSzzds7cl0Y8MnYRxWvV59Hc/Gdk0S7AZJQ6lblzTXPdOtEqRozonIvP/LLcHx9Uf2lbvXmOFPqowvYXsjX9jRsXmPt27YJ165g7VzSp228/Fa2fQhIiQXPzn3mt+rxgPpE5tppUWeZt4vFJNDfnr1+zfik7Hq9NHeT0PXDikMffwp4eKawDOHSoiQnYsIEOs9h0B2ah3EXyg+yOO0DM4UbSMY25c+H45HZprkjJ31isUz0oN1CiJ6FT7HNr8uordt1RV1koeh6TE0hhr9OaNnftglSK48+U+Zg7t5zFi6chARQAa7njjlO428xn2eLF7IDcfJds2EAiMSkXig7eJzVo8b8kusXPjqco9oG3Z4+8bDsSMUuZVq7HxPaRRaJkuOQSAH55BcCbSEQfwLHMmUMuui2X3dxW04UgW2o3D9rCh3BXwshqgAeCffuCCrjd0e1zJhQKchiNGSPbtm2TOTDzMWfOJ1m8+FjALGzmTX75S7j7AZnP+OLF1ENuvhPr11P5xc8QiQRCqvD/5BkEfAjmvsGOnx2Px+MZKLy5r0e8kPJ0ic0yAaJN7N0bfJbTpF5+me3OMeOB1nMvBGDnzg1I4LT4XIYOncasWcDqlOzc3h5oFzYKzpTdKPRFuZpBoeZ0ILWmYnzQc3SVkDZs61G5WmNLSy7CcdYsmaO2tvHmmDfYuXNDbj7HIymS7HwnXn6ZykryNKm9e2WsbnFK/yP9IMdrUj3iZ8dTFPuwKwxtHjECStLvwqZN2OpQYSCWSPCIrWPIK0ArxgjIrFkwtXJ3ULXPmsDcooWRCO3ZzsLJFUy9ERiF5rkPms+uN4LwgwqunJByCyeGQrn5mFq5m1mzSlm50qSEog54hWXLjgbgwkSCcDqdm282baIk/S4jRoynsVE2Wd+hN/cNIvo5BP1QwAspTydsZJ8rLNrbg4f9qFFILrpUit3mmAjAjBk8/bTt5W1kCYU8dKdPR3L02UU9oZBIOyear7CqrhUW3QkEVyANHSrd2pc9DZgy8L3Alp0vvHZXSHc1pp6EVgcl+dV9R4yQwdn5qK9n+vRjHCE1BHg7N58XzphB5LHHcvNNKgUNDYwaNZ533uk8VjsmH+F3kOM1qR7xs+PxeDwDhRdSPeJnx1OUQm3CEo0C6TStmQy2UFg5wPTp/PVRu1cTkmVCNIOaGqSsunWgHHaYpFF3NKlCsyJ01lCGDAk0ukKtKRzqCAabLTL4YrYw00mJeR827XAoBBE5SWFovKvxueO0EYHudWSzUOpqUiNHSgGo99+X9ubN1NQck5svmbsm/vpX0/zsdEofeyznk2rNZAin00Tj+ZfWm7B9z0GED5zoES+kPD0SFPmTdjQKbEyzmyChbClAdTWbNtmjdiBGQFmom0wCm51SvsOHBwLKdNye7fzALzTnObuLUMpmoSWbP9ADkezP/XVrJGFOcEUiEI3kCa1stnvhGgohws5d4Dt8eCCkMhmZIzNfMnc7gvm8oZpSyJXu2A0ipJKdizF6Bhlek+oWPzueLnEfeIVZtaNRIJMhS4GQqqoim91mtmSRyi2jAbP4t85mREe0CFNyvTDLuSuYhg8PzhuJQEl7a+fVq109md2DXHV0jaQjAAAgAElEQVTL/cy92MIL78opZclmRWgZgROORIjEwrlhtbfLeqXCU7S2lwRZKCKRoJQuwK5dJmn6aLNhBLAtmM+qKkoJ5jsLkMnk4i+KDd1zkOPNfT3iZ8fj8XgGCm/u6xEvpDy9wjX3RSJAS0vOHwUSgi6qgA2SbgXCjBwpatFhh5HTQABRkYyW4/7itxF6IH9LIx1O3fpsfgJBOyhXO4lE6AiF85StbLazYuRSGA0YiUAkiIoPtDdXVXI7bWmhJBIRnxNANEIo1PV6r7A7ia6amM0aN53M186dYTOHZj4TCZljZ3Zpacl7vnnNaRDyIWhSSqk5wI+QkNH7tNa3F3w+DPgF8AlgG3Cx1jplPvsmcCWS3+xarfWT3fWplPolMB1oQ8p6/C+tdZ+SlHkh5SmK9bEUrhsaMgTIZvOyF4XBLFRNOVuH5uIEhg83m1xpYF6Fm+yDtyS7WwRT4dPeEUodkdJcFHcmIxHdO3cGFTGsLLHmt2Kh4tbEaOWGPcWIETByZJhoNEwsVgaIubMku5uikjCbpTQSoSNamjcGuc7O12+xbjqAnTvt4i4z8FhFnpBqNx0XrglraztweQs9HwL9vE5KKTUEuAs4CyliuFYptVRr/Yqz25VAs9a6Sil1CfB94GKl1DSkbMfHkfXkK5RSNudxsT5/CVxu9vkVcBVwd1+uwQspT6/J+8FX1A9kn5D78o7JHWvf2KdrezvhiHhawlHTb0uBz8l1hkWj7GgRH1amSQSTTSxuhVSh5lQ43O5cUoXjtQLLTRYRi0EsVkosJkKoLNGRnybeDKDEdFwaiUjQBARRh3YOnMEUus5kDrspDmX69y6NQUz/a1InAPWmOgVKqUXA+chqe8v5wE3m/RLgJ0pK654PLNJa7wXeNPWmbIWLLvs0JTww2/9GEK663/jb29Nr8uRS0YdmSd4m97ld6v7stytNXfOde4AlGqUjKhpMJgNN9UHSikwmX2tyAzysRjJkSOfgC3f4blYN296zp3OZkpaW4LyiXbm1GkuIx8uIxWWcJS078s2Dbv0M90QFYYzZbOfLz81nN8Eh3sw3iOl/ITUB2Oy0G4ATi+1jiiS+j0TwTADWFBw7wbzvtk+l1FDgi8A3+jh+L6Q8Ho9nwOi7uS+ulFrntO/VWt/rnqGLY3ThKIrsU2x7SZHtLv8N/Elr/WwX+34gvJDyFMUumi3MfbdvHxCJ5N081pEvi1BB/KlZdu6UVksLlA8dmq+6tLQEJTugs1MqGmV7poSmemk2NcnL+qBsVyNMNRCr3cTjJlADSeEUprVzjXVX7So4Zythmpul+f77ck6rtYEkct27NzAzNjXJOW1ZrHi8jPJ4NP+cLS35mmOhXXLo0Jw/zRxk5nB4bn83UCWE/A8KfWxDh37wXIWeAaTvmlST1np6N583ABOddiXwbpF9GpRSIeAwJJdxd8cW7VMpdSMwBvhfvb+M4vRpdpRSMeA+oAaRpP8TeBV4GEgiXvTPa62b+zRKz4Djfo+yWSAa7Rxt1tAAHG62iJDKZsUWl8mMYJKbsjuTkad7JJKfGTwaZbesuqKpAbZskdJLEDzArTyxAqmiQtoVo1ohnZZXXTo4TybTfWXAggjBcCxGhRlTRSLB1MoETE+wtVmueOvWQHCBmAc3bw7azc0wbpyYAAFKo6FgDK5kc8cViZimXUtmhdQoaTa81TmaMhrNMw9639QgpP9D0NcCU5RSRwDvIIEQlxXssxT4EvAcMBf4g9ZaK6WWAr9SSv0QCZyYgkTsqWJ9KqWuAj4FnKG17l3CzB7o6239I2C51nquUiqMrOn8D+AZrfXtSqkbgBuA6/t4Hs+HTFdJWp2Ia4jFiBDo/bsBUimUOh4ArYcCLdgcCen0CI4ZMiRfSGUyImXsCWIxtmdLSRv5kk4HCgiIpjR6NEw0v+HGJzokae2LqeCAdDpf3bId9NZxYy/czVYej0MiQYWstqUimYTZVbyblqvfvFkEqb20rVvFT2aHkEiUUh4j309VKDyHDDHXbXNKtABDUcos7k39kd3OfEfMfLnz4w7fvvcc5PSzT8r4mL4OPIn86vm51vplpdTNwDqt9VLgZ8BDJjBiOyJ0MPv9GgmyaAe+prXeJ8Pu3Kc55T3AW8BzEnvBI1rrm/tyDfs9O0qpMuA04AoArXUr0KqUOh+YbXZ7EFiFF1Iej8fTmQ9hnZSJuHu8YNt3nPdZ4KIix34P+F5v+jTbD/jF9KXDyUAjcL9S6ljgeSSSo0JrvQVAa71FKTW2q4OVUlcDVwNMnDipD8Pw9Df217nrTiGRoJQCTWrTJkkkC2zYUAZswRY8T6cPh+jwfIeSfW9Ma9uzpTQ0BFF0NijO+nomTICK4TtEewJYXU/eAZlM5xxOsVhukS8gqYgKnTZtbUFVx8I1T1bjSaXccD6orGR8VRUA44+qYuueslzJjKYm6cJqhO3tQGUp5bGYMYkS+OPspA4fbva3BeJ3AeNy88mmTXmaVCnyP3A1KTevoWeQ4OtJ9UhfbukQcDzwL1rrvyqlfoSY9nqFiUC5F+C446YXRoZ4DgIKF9larJAKx2JEjI8lC/Dii1I3CtiwIY7UlJKHbn09MDtWYDNEQsxj5QCk6+QBb3cZPRrGjYNJCeONqauTjkw127yHPDImYjE5cMyY/G2O38vWrbLXVkIHeSuCM5lAwjQ2ii3PLsIC+SyTCQROKkVFVRUVNdUAvJ0Os2VLkDu2qUnOE6sup8SaEd05AIjFqF8PgZBqA+K5+eTFF8lizHxAOBYTIeXk7O1ifbDnYMfn7uuRvsxOA9CgtbbFBJYgQmqrUmqc0aLGEXzrPIOEUCh/nal98NlMBs3NQE0lTJlCZO1awCTvWbuWM41h4P77DwfWA1sBkS9ckgh8PdmsnCQWy8USFGpOySSE02/DqjrZkErlCyYbOWF8RSSTUCW+os1mFcfWVPcuKrm2EqJRm02ijHh8EhUVxwAwscbxfVnhWOj3qjeLt4xgm1RdTeK4SbndrWaVySDaFAQTbH9FJxIyR2a+RGc6nDPPNM1vrSULlNl/0pQpUFlJ85vB/6VQSBWsFfYcjPjcfT3SVbx7r9Bap4HNSqkjzaYzEAebjRTB/P1dn0bo8Xg8hzLur4sP+voI0Ner/Bfglyay7w3gy4jg+7VS6krE3tOlQ85z8FNY7cKyaxd0JMZTUl1NzGhS24GWVIpzz7V7HQ08g1Wk162D1qpphCeYBevbtkm4ntNxLCZrnipGmiLpdfWBlgKijsRi4pwCOOIIqK7mtXr5rVVfD6kVotA0NgZjdYPqiuW1s24q676ya6/GjIFEooRkcipVVZK2bOqZHaIavvmm7PTOO3ICqzq1tBCuyjDV+KwOO6w0lxUjd712Uddoid5rrZrGunUQGB6iwNG5+Wz5Qop2IGYHXF1NR2J80C+BYvYReXYdGnhzX4/0aXa01uuRjLeFnNGXfj0Dj5uNfMiQ/HgD+zyeXFMjFXmRBXFpoOrZ3wMwatRnaG4eB8gSuTff3MaKFaP5dG2tHPDqq/JEzWYpNz6n8igikNanZJ+GBjGpWYlhzHm7E5MB2LABXl1Anlmt0E3l5t6z7cKkrDZDEwSmQLs2a9s26b+uzjVDlnDkkdM4+vRpAJSm3xAJaSVjJiMHGHNgRTIJlebgpmBdFJWVcKQYIlaskDmy8wXjGDXqWMrMfNYjv/7sfFNTQyol12r/L8OG5Zv4/KLeQYA39/WIF+GeorhVNQqqStDQAJNraxlrnoThtjbeA6oefBCAa675DLfdNg1ZSwjwPEuWnM2n7ztHmnv3ijRoaAgWuNqIv4wTDVBZacr6QkfVVNavhzqTTSyVEq3JFUo2mM9NBmvWCANdaxqFiSDcIVihZ68ZRBg2NMA//iHt6urJ1J45mZL614KBuYEVLS3kqhO6wRLJJJwj87HkKpkjE4ICzOCaawAzn+8hC3jtfFNbS0ND5+on7v/JMwjwmlSP+NnxeDyegcQLqW7xs+PpkVwhQGOVaG6WdEWcXgszZwJQ9uyzvAe0Ll4MwLxtcNttMxHtAOBF7r//dM49VzSBC6urxVG1aVNwImtjtGpPZSVUV/NuVoxc65eLVc1GhxdGA8ZikiJpzJj8ba4mlQs5d8L73JD0Qk2qqUmseFu3BttsRnSrFNnAvtpa8VmNnx4Xc5/VpBoa5HyuQ2zkSJg+nUceFX/a/fe3AS8SxDLNZN48aB0t85kBxkJuvqmtZctK6bI7LdFzkOPNfT3ib2lPl7i+Gyug3O/Stm3wbvtYxs+aBcDYZ5+lgaBITe2CH3PSSdfy3HMmsR51wBP89KfnATDnN9MoXbNGfFNWQsRiYgKzIeU1NbyWLmPjRmlaK5p9EFdUyDoqu3tlZbBEqqTFVLRtaYGWdsh0UVjKUEJQMbc8FKI8FGJSUp78HTVluaVSVuak0yKkbdCCXdtlTYY1NeVMrakJzlVX13nwtbXsTk7jp/9mR/GEmaMpAJx0UhXlC37MevNpK0ZImfl+t31szm9WUJg493/zAmsQ4M19PeJnx1MU6/6wys2wYcFnNjZg/OzZAFTedhvrkRBPgNobb+Smh6/lU5+aZrb8GXiG5ctFE1ixYiznxWL5mVqTSXnKGh/U25ky6uoCzamtLT/beCIhgqnSlFUrZbf0Vd/SdRLZrt5D/sIpN7ceUBIKURGNUpGMkUxK4tuGBnnZcTU1SZJZ2xbNs4xJ5jpyAsrNWhGLsWIFLF9uo/lsJOT5ANx0E3Dxjbn5DGGqx5n5rquTLm1QCwRuLx8wMYjwGSd6xAspj8fjGSi8JtUjfnY8PWLXDY4cKe3hw0V7SKWAuaIZlcycSdmaNZj4Nl7KZDg78ifycw2/gZi1YNGiL3Het6vzkwK2t+c5mZrqRENxSj3ltCcQhau0fQeknXVUbiI7+9fN7FC4ENJqUa4m5drubGhfJiNl4IGpiTiVlWW50HerVdku9uyR+ZlUHQ/GYPu0562uZtGt5OZD5iacm6+zI3/ipUwmlxN9qplj65NKLZHu4vHg//IRWt956PAhCCml1BykYsUQ4D6t9e0Fnw8DfgF8AtgGXKy1TpnPvglcCewDrtVaP9ldn6Z8xyJktcTfgS+a5OP7jb+lPT0yZEi+T8r+bWwUkxzApNNPJ7FmTc4n9RpwzK238pWvPAXAT39ahXisVgGwcOHF3HrrNCYfeWR+yLlDJCJFC0eZkkrxuEkyO8rc8zaHnmvas4uinFIbHaFwXl7btj3uWcJ5a8KiCShpb83Po2QLFDpx6qWxGNOqxBk2enSYeDxYc+zOUR7RaG5d1BuRaSxcmM3Nh1DFV75iEh/deiuvIfURABIAp5+em2+7JKvw/1K4BsxzkNPPgRNKqSHAXcBZSCq7tUqppVrrV5zdrgSatdZVSqlLgO8DFyulpiFlOz6O1JNaoZSaao4p1uf3gTu01ouUUveYvu/uyzV4IeUpin1wt7V1Kl5LJCJLnWxC8kmnnEKSYLHpdqDp6ae53Tj3f/rTcxAhZZ/kT/CTn1zAD6+6IMhAbiPgzNM+mZyUW/cEUB7rMAUNTR9WkLhVEM1rd1ai5HY2S4BDocupEFfRGjEizMiRciWlsViQdNYN73NCACvicSpqE2zPlOTOEYsRSC3rTEsk4IILAPjJT2QOgvkAOIfbzW/cptFPs92ZzyTAKafk5nvv3kAeu2N3/3oGBx37n52uN5wA1Gut3wBQSi1CHJ+ukDofuMm8XwL8REkxqPOBRVrrvcCbpt7UCWa/Tn0qpTYBnyQoqvig6dcLKU//YjUN9xd7NFqw7rb2KCJHH01iwwZASne8Cxyz6hEARo68kJ07HyJI+7OBBQsu4JprpkkkHEg0wLZtkkoCKJ2YESFh1782ZfOlTDyepzV1RMtk8W0634LoUmwxr/v+/feDyL1IpIRIpJxYsrwgYrAlOImJRy93fxHXZ8hlud22TU5cXc1rIQkkWbBA5iBgLCNHzqbczNdLyJczYcd99NFw1FFkTLifDWZxNSkfNDH46Ogo/sPpADEB2Oy0G4ATi+1jiiS+D4w229cUHGtyknXZ52ggo7Vu72L//cYLKY/H4xkgtO590egixJVS65z2vaYMkkV1ddqCdrF9im3vSvXrbv8+4YWUp9fk/DaOyydHZSXMnEmV0YKyGH/KsmUAfOtbF3LDDRcCj5gD2mhsfJMFC47g5pvmyqYnnhCtw6ox1udUbCBuBlwC5cYtBNje3jn6vKuHQqE25cZV2L7LrMpiT+A6ugrJZoPriMXgYx+Dc85hwU2yqbHxTaRmlK0JeiHf+ha5+WpHnABVtr+ZM2WOjSZl/wc27NwzODkAQqpJa91V/lRLAzDRaVciRo6u9mlQSoWAwxCLfXfHdrW9CYgppUJGm+rqXB8Yf3t7imK/PG69IpAHYzwueV/tc3t7S5jyOXOoXC9P0dDatVKtd8kSAK5fcgnb/v0z/OAHR5jenwVWcsstLTz66NEAXHfdZ7jiCihZIcEWrFkjIYSu7ymRgMMPl/bRR0M8zu72MCAyrbk5SAtox+wuTLamy8LgPnuNNtmse/ywYRK8EaqU85SGQmLiMwKZt97KTyIYjUrooYnE6zjzbB54AO6shQ32GNYi3+FLAfj3f5/G9cc9Bd+T+YohQioxY4bsPmcO21vCufmuqJAoy0Ih5Sa18MLr4Efrfjf3rQWmmKi7d5BAiMsK9rHllZ4D5gJ/0FprpdRS4FdKqR8it+MU4G+IxtSpT3PMStPHIg5QqSZ/G3t6RWExPftwdJWL8qoqbCnZxIYNvJfN0r5zpxy/ejWf+9zZLFggPpktW95DMn535DI5rF0rysLs2WcDEE4kTKrzV2WHdDpfu9q2DTZvpvSoowCYWl3N1sNK2bo1iFlwtSr3Wly6+tyNxaioMOVD6kzxxU2bJLusHbjNz2QX7x55JBx9NK3VUjhx1Qq5Ntm9w5xlFDCKceNkPj73OeD3q3PzFQXGRiK5+aSqipaW/EAwG83nAyYGLwdAk+qhf92ulPo68CQSLv5zrfXLSqmbgXVa66XAz4CHTGDEdkToYPb7NRJk0Q58TWu9D6CrPs0prwcWKaVuBV4wffcJf1t7PB7PANHfQkrOoR8HHi/Y9h3nfZYidf+01t8DvtebPs32NwgiAA8IXkh5eoX7RRo+XMxibmTZsGGI2mF/+Tc1MXbt2uCgdJoTx73NvHmTALj99tk0NjYAQ3J9p1Ji4bPWvaqqY6i+6BjCKbNEeP162Lgx0GBsEldbM2PTJiqOOoqKqiq2Vsh6IqtV2T737JGxuwwZItcEgSmzwqQcrBi+Q+LsrfYEQZ0re/HJJNTUgKmV1ZqcSl0d1It7iY0b5drkOq0PajRjxlQyb560Thz3NqTThIw2NhZgxoxgPmMxhg0LsipZE5EdN0j/fp3U4OJDMPcNeryQ8uwXrjkMzILbhvZgQ3V1fnRFVRVkMpx5pgipdBpWraqkqSk4ZOTI/LpNLS3ycK+slPWD1edOpbS2VmxnAC+/bNZNGTNcQ4OYBquqqDBVcSuqqmitHpvLq5fJ5AsqK6DsGBIJCGfeCxaA1dcHqddd31gyCR//uLRnzGB35dRgGMvzl1Vls3JtMgXjABGEs2fDmWcSDKyqKv/XQGVlMLD2dkYlgliMIuufPYOMD0OTGuz0SUgppf4VuAoJM9yAlI8fxwFOi+E5OHH9VOFQhzzE95h0DsOG5T9ka2qgqop28yBPJiWhdyYTJEi1Gc1d2eY+7FMpmDBhKsddJEIrfPRLUu7DCpR0Wt43NJBLnV5ZSTiRYJJJlT4pHodxBaGJLS2QMk6sNcbv5VY4LPQ5Gd+b9Tm98AK8szG/nmEoFCTCtRrn6NHBumWb8D33gKquEk3MTqidGDufLS2EQx2EQiW5/v3DbfDzIayTGvTs91JnpdQE4Fpguta6BnGg2ZQad2itpyCe8SsPxEA9Ho/nUMNqUvv7+ijQV3NfCBiulGoDSoEt9ENaDM/BhxvqnKO9PbBH7drl5AcCYjG27izl9del2dAgSoKNngPRLCZODA4B2LlT/EogysWrrwbtZPIYjrmiRrQpEO3JmubcgoNuIUWr1rgx6AV5+TrlAkwmRXuymTGmT+eljSWklgfjMpcIyPXYpK/288MOE8XIjn3PHhmanY8JE0qpcC/cjsPOZ8ETyYbN+4i+wc9HRdjsL/t9i2ut31FKzQfeBvYATyFlWA94WgzPwNPVw7CtLXi2t7aXEHYf/rZ8rf0GJpOMrDmB99+Xpo15MNmCAClWGI2KPAAIt++GUIgdWVmfZLONW6FQXw+ZTAnJpAQTTaquFkFliwxCcICNSXdX+boX5i4Ci8WCSorJpAywpiaX3DW1Oj+ZbGVlfnb2skgrtLfTGirNXeuuXRJ3Yf1W2azsby2II0eaC7TjbmoSe6GzYLm1vSQ33139SPACa/DhzX09s9+3tVJqFJKA8AikuvVi4Jwudu0yLYZS6mrgaoCJEyft7zA8HyKFD8F9+/IVkHJbq93S1BQ8zaNRSquqSCaPyX1cVwc7d7axcePQ3O7t7UEXk2NZSKcpMwJlWizGtNmVvJsWK7VdPxssVyqjsvZkSquqgod9KiU72HFkMvklPeyiKKvFxOP50iOZZHd0bF4XoVB+AeHxiQ4jYDLBDokEDRkRUmvWwPLlsGoVNDeLdBk5cmjeaUrrjX/NSjE7FjsZsVheusB9+3wF3kMBHzjRM325vc8E3tRaNwIopR4BTqaXaTFMfql7AY47bnqf8zt5PB7PYMOHoPdMX4TU28BMpVQpYu47A1gHHPC0GJ6BZejQ/LVF7i93G3yWyUB5pVPb3WomNvZ7zRoYMYKz/yUJwMaNZaxbBzt3vktzs/hdfvvbCjZtGp3TjD772XKOrwrlh4OnUow35xifTNAaLc9pOFlRvBgxYiyjamU9Uri6Ol+j640mFY/TGhHTXnMz7EoH2pPdJdyyPbi2eqMC2j6SSf5eX8ajj0pz8WKoq9sGbAVGmOk5nFmz4OyZJrP6fz0mc2THmUhIf3Y+43EyDcF8d/W/AJ8FfbDhName6YtP6q9KqSVImHk7kgLjXuD3HOC0GJ6BwY0tcNPvQCC4bEh1SwvsyIYps44ZG35uzW6bNklHJqLgmmuupaEB7rijEkkvBvAWdXVxbrlFcvmtXRvh0kvL+NSnjgegIv62mNWc8PBwNJoTWiTitIZKc0lm5RrKCCXKiCQnA1BCR5d5kGxNHyu/2s3xw4fLGrBw++5AgGxsyi/VYXL1bR0mZusnH4WFC2H5cvsTeQOSe3MUIEUP586Fa64B7ntAdnnySYmisBEXsZjMoZnPHVkp3Gjn2y3L4aarctuegx8vpHqmT7ez1vpG4MaCzQc8LYbn4MJ9CLpZwpuaoMxdS2Q0H0C0DpN8FqA0EuH6668mkxnC/fdPM1vXAK8CbwGwfPmRrFp1NBeZhC2f+cwkZs+eRIV6L+izpQV3pW44GiXsVErsiJTmVYNvby9ByrR3fU1WsSrJ7pYN2Sw0ZPKFktWajFNqqx7LqlXw+9/Lx4sXQza7wVwLSE74scA0vvxlkSTXXw+lC+7NJeDNzc1Ek1zaRhSa+WxqyA889Pn6Dg184ETP+Fvc4/F4BgivSfWMF1KeXuP+ei/8BZ/NQmOjlF4HSUdEdXVgmkunad+8mdCzz0q7rY0K4LbbriYUEv/PT396CvAnxN0J8CzZbD0PPSSa1rJlRzJnDpx5pvibpk8fS/V04x8C8Te1t8tfM8CSSIRwJEI4F8rdxeDdlZHZgnVT9rNoNGd6a42WU1cH60xuvhUrJHqvudlqTq8gSwZtIr1JwCl85SsjuOUW2VLxu3vh/vvFD4XYy0MTJwbx99XVUFXF1maZz8bGzr+47f/Ba1ODFx840TP+9vb0SOFD0K3RZD+zNf7sYtVR1ZMI19bCli2yoaGBUDpNi1ngE1mzhlA2S0U2y513XgtALDaC+fPPQetV5kyvICYzEXTNza+wcOGRLFkiQmvWLCnZdOyx5QBMmVJOImECG0KmJEbh0vyeluqHQmLKMxfW2l5CU5NYFF83rrMXXxTZsnq1tNva8scJu4AyrP9JqdnMmwc33QSl9/1Ydrn/ftrXr8c+n6JDh+bnA6ytpTUxia0mIn3XLhm2zZlo576rWlmewcNAalJKqXLgYSAJpIDPa62bu9jvS8C3TfNWrfWDZvsngAeA4UhG9G+YmlJd9quU+gJSygOgBfiq1vrFnsbpb2nPB8b6bdrb86P+stn8PHtTbWQdSO2nxkbCZh3QDiCyfj2ld9xBqdnn/91wHclkOfPnzwbgzTdHI3E5RtCxAXiDtja5r1euPIKVK6cwZsxoQFLfVVfbNUwSCBGPhznssHAuW3ih9lGYYmbPHnj//WDY6bRcS11d4DZqbNwGvA68acb1LiKYrK9rHHA8RxwhASDz5sH/vmQ73H4nPPQQALtTKbJI3ShAKvdOny6ZzwGqq0ml8pPUuuMePjw/cYZncDLA5r4bgGe01rcrpW4w7evdHYzAuRGYjqx5fV4ptdQIs7uRta5rECE1B3iim37fBP6HEVjnIIF2J/Y0SH+Le3pFd9qUbbsV1dNpiERKmWTKV9hMsWGT5ie8eTM7gGwqRfmdd8o+DQ3872uuoeYBibu5886j+e1vD0e+AyDaShOydhwkRudFGhvF/Pf00+N4+ulKYBzjxsnAKislseuoUXJENJpfOBDIiwZsbhZ5aq2UW7bsQ4RkA4GwfM+Mw+pBJUAcqznBTC64oIzrrpPWaZG/wbx7YMkStpuihq2IgArbQImTThK10MzX202leYnX7Ry7823bhVF+nsHDAJv7zgdmm/cPAqsoEFLAp4CntdbbAZRSTwNzlFKrgDKt9XNm+y+AzyJCqst+tdZ/cfpdg6yj7RF/W3s8Hs8AcQA0qbhSap3TvtckSugNFXZpde4AABctSURBVFrrLTIOvUUpNbaLfSYAm522TXU3gcC+7W7vbb9XIgKtR7yQ8uwXrskPxOznhnq3tIg2Muxjcn9WzJyZp7JEd+6kNZOhBdhttIv4/fcT2bSJ0778ZQBmLbman/ykjLvvlnLydXVHAi8iGhTANvP+LdOOIL6gUWzZIsEYW7aMMttGmH3CwFCCoIZ9QBui24CY7XYgCfxx3u8g0Jz2mX5Gm/Zk4Fiqqw8H4Ktfha9/HUruM8+K++8nu2YNTQTF46NANBYT7QmkuNTMmWzVMl+2rqKdX5sX15otvanv0OAACKkmrfX0Yh8qpVYAiS4++lYv+1ddbNPdbO+5Q6VOR4TUrN7s729zT6/pyuRnTWdWQLmBFG4SVj42iYpZs/K+keVPP01HJpMz3jUAZWvWMPbllwEoWb2aay+/nHN/L0LqgQcOZ8GCw3nzTSuUXkEiAU20Rk6gvEUghKxQCjvtwgo1HQRCqpV8oWWdbkMQYQdQgUTsSQDHEUcczuWXwxVXyKeT65+CKxZgU068t3MnJq8ENs95eSwGZ50Fc+bIhlmz2DpsUq74r81jaOfXzrXbtqY+L6wGL/29TkprfWaxz5RSW5VS44y2Mw6xYxfSQGC6AzHRrTLbKwu22xR4RftVSh0D3Aeco7Xe1ptr8Le3Z7+wGSecJN2MGJG/2HTPnkJBNZmKM51bLhQi/sQTueiA7UAayFjN6qGHKF+1isnnngvAzZdcwlVXncbChaKx/O53h/Pcc1mCRbNvIH6jZkQjAsnYtYtA2BTUjs8xxPlbggQsgWhgo5BgiMlm25GcdFKE88+X1qWXwqTUn2D+ItmwbBnbN2/GXnoW0fHKgbhNnXTOOVKW15TmtQLKzteePaI12fkdMSJfe3IzTngGNwMYOLEUSV13O8VT2D0J/KdJKA5wNvBNrfV2pdROpdRM4K/APwP/1V2/SqlJwCNIIdzXejtIL6Q8Ho9ngBjgjBO3A79WSl2JmCQuAlBKTQeu0VpfZYTRLQS5y262QRTAVwlC0J8g8DF12S/wHcRG/t9KKYD27kyVFqX1wCcgP+646fqPf1zX846egwZbdM+GoFt3k41Gs3lcbd2joUNl/ZJdqzqed2WhkV0JC2Q2b+Y9ZAGFpRRJKARQnkiIicxoVnz2szy1KsyKFdJcvVrWL2n9FoGFwUYD2sysWUSbcs14QxBdB+T7FkOi9QDGotThzJwp67JAlJ+zZ7fmzHksWwZPP812k57pPWC3cw1Rcw2xiRMD896ZZ8KsWbzLeEAySDU15c+Xm/c2Gs2PTPSmvsHLYYep5+3DOR6frs87b/+fffffH/R1qOJvcc9+Ucw/ZU0X0WggyEAE1pYtTmKH5Hgx48ViuSdxbNUqSteuzRm2t5uX9VmVptOUP/QQ481ao5IZMzh79mzOttLjhlm8ki5n/frD2bhRTII2faCbBN0N67ZjdZOg27R5IMV4a2thWmJ7sHp3xWr49io61sqPy3fNOK1g6iAw7wGMB8IzZkhwhDHvMWsWb6RLc6kNGxs714hyhZI19fmFu4cWPi1Sz/jb3NMnCv0ihckdLDaDt80FK5pXKdWzzyZsqwdWVhKurCS5ciUA0UyG9wiElBVaNmlS2dq1lK9dS/wHPwAgnEwy7bjjmFZdHZT7PdckaTWZ0ndkw+zZE2iAQ4aI76csYgIlmppEqtnyIBvrYEkdvPACrUaiNJlx2GAIG2JhQzNiiOaU8z+dfroIqNmzaa2Woo+2MrFdrNveLkLHRu8Vak6RiJSf936oQwufFqlnvJDyeDyeAcJrUj3jhZRnv7FZJiCI9nOrx48Ykb+/W+2iqQl27hRNoqpKtIvxl1dKeiCjBcVXryb+7LM5818Tor1Ya90OxNRmNZjSVIpoKkWUIFg8CoRGjpS0E0DZyJGURSKB3WzfPhmUiShk2zbad+7MO0eLeVlzXiti0rOB7KXmfNaLNR7g1FMDJ9Ypp8BJJ/Futpx6kzxjyxbRLN11UFZ7snNnt9m5drUob+o7NPClOnrG3+qePlFYGNFSmHqoEJtofO/ewORVWVlO9emfofSoo2TDxz8OtbWMN5nCx69dSxpyod2uAIHALFhCcGOHgNDOnYSMEArR9Sop+2O23XnZtl2Aa/sMI0LJCsI4ZrWkzbs3cyaceKKkOgJ2JyZ3Mu/ZNWV2nqyAsoJ95Mj8kHNf0PDQxGtSPeNvec8BofDh2ZOQgkBQWT+VLZxYWSnrkaoumiwBB1YjWbeOxPr1JEym15bGxrzAih2IttNKkBuiw3n1hhLnBSKQIgTaEojPqRyIjhkjG2pr5TV9eq7dmpyac2s1rJbrKszD52pKVkDZwrx24a4PlDj08UKqe3q87ZVSPwfOBd7TWteYbcVSsSvgR8CnkefFFVrrv/fP0D0ej2dw4819PdOb32YPAD8BfuFsK5aK/RxginmdiKRy7zEVu+fQoCttyt3magOhkLiBdu0KvqQ2PNyGizc0QCIxlapzpwJQOmsWbNwooXFAdONGonV1TDLt1sZGMuT7j7Lm5ZrvINCsrMbkmgcjBKumShG/VgwIW83JRg/W1ATtmhp2x4I1T+lVwXUU5uCDQGtyNalCH5TPcH7o4819PdPjra+1/pNSKlmwuViK9/OBX2hZIbxGKRWzOZwO1IA9BzeFQskKoGg0vx6SfT90aGAGs4EVrtCy9ZwAKirGM656PJPsWiMbKm52CKdSjE2lGNvQENgQGxshk8nLzFdo+ishP7MfsRhYgZRISL2PZFJeECykMu23G0rYshm2rgvG7Qome71uYIR9b9vWvOemmSqcT8+hhxdSPbO/X4FiqdiLpXX3Quojho38sw9bu6jXfei61WXtZ25tJyuwbLBBOg3/+AfEYqL/jB49mTFVk0kYl1Vp+w7ZKZ0O1JimJqljZToNZ7P5VQ7tANwIhlgst66KeFwEVSLBblPmPp0W2bfNVM21QsmtOO9eq6sludF7w4fna06F66C8gDr08eukeuZAfw16nb5dKXU1UtWRiRMnHeBheDwez8GP16R6Zn+FVLFU7A3ARGc/N317HqYw170gufv2cxyeg5jCdVR2m/u5zVEH8relJb/ch1V8QKrmNjcHlrxC7SQaLSMaLSMWn0o0KdtiMdkvbA1+hfXiC+rJtxLO095aWiDTBC2pfLOkqzm5+fZsl25ZDde0516ru4/rfyqcJ8+hiw+c6Jn9/SoUS/G+FPi6UmoREjDxvvdHfbQp9rC1/pdIJPiSDhmS/+C2pj/7uRVYbj7ATKZzmHahb0cEQNiMJ9xpTK7MsklzXdNd4XndlEqF57XndAVSNCqmPLv2yc6Lz8XngYHTpIpFaXex35eAb5vmrVrrB832TxBkQX8c+IbWWvfUr1JqBlI+/mKt9ZKextmbEPSFSJBEXCnVANxI8VTsjyPh5/VIgNWXe+rf89GhMKiira1rn9SwYdLeu1ce8IU+KldouZnYbXXgYueE/AXHLvsKykx114/VeoppRVZA2esYPrxzYITXnDww4Oa+YlHaOYzAuRGYjrhunldKLTVC527EZbMGefbPQcp1FO1XKTUE+D5Sp6pX9Ca679IiH53Rxb4a+FpvT+756FH4MLbCyn5WqEm1twfmvK6ElNu2GpEruOz2rt53N8ZCYeJuKxRKXbULNavCkPKu5sLz0WOAzX3ForRdPgU8bWtIKaWeBuYopVYBZVrr58z2XwCfRYRUd/3+C/AbYEZvB+m/Jh6PxzNAHABNKq6UcgtS3Wv8/b2hWJS2S7GI7QnmfeH2ov0qpSYAFwCfxAspz2DABla42oUNS4egPpWrKe3ZI2ZA23Y1KdefVKg99fZB4GpMth34tYJxuaa7YcPyS73bzwrz7nktylPIAQhBb+qu6KFSagUmtWQB3+pl/8Uitnsdye1wJ3C91nqfqczbK/xXxTOgdPWwtg/zQp+VXXdlBY4VWta05wbuufu4AsqaFoud046pcNFxodBxhVLh5/9/e/cbI1dVxnH8+xOEiEBpU/5JqzSkokCkhaY2EhUF2koIxRdGMLEVJRUsiSYaAXlRhWBICBARwRRogIQ/IRGkGqAsjS2+KNCWFEqp0BVIWUAKlCCBBFN4fHHP7d7Ozp07O9vt3Z35fZLJzpy5c+bMzZ19cv7MeZoN7ZV9VrOIdneW7KTuOL3sOUllq7SLBhgcuoNsxfbqVD6loTxfyV1W7yzg3hSgJgNnStoZEX9t9Rn8tbExoxiMIPsnX5yz2n//3RdH5PNVjQGpMSgNZ1EENJ87agxCjX+LCzIcnKx9AXxcedQoKVulXbQS+L2kienxXOCyiNgh6X1Jc4AngYXAH1vVGxHT8kol3Q78vSpAgYOUmVmNgsHczntd01XakmYBF0bEBSkYXQmsS6+5Il9EAVzE4BL0h9OttN5OKVuQV6+ZM2fFmjXrqw+0ntTY8ykO2TVbxddqNV/Z3FRjb6dxXqqxzD0n69SECdqQzyNJJwWsGUFtB29oNSfVDfx1sjGv1T/9YoBoHBbcE1oFo5yDknXuE2rsSY0L/nrZuNNOUCgLKKP9vmbDV9uc1Ljgr52ZWW1qXTgxLjhIWddwT8fGnwBKfhdhgIOUmVmN3JOq4iBlZlYrB6lWHKTMzGrj4b4qDlJmZrXxcF8VBykzs9rUuuPEuOAgZWZWG/ekqjhImZnVavR2Qe8Gn6o6QNJySdslPVcou0bSvyQ9K+kBSYcUnrtMUr+kFyTNG62Gm5mNf/lwX6e37lcZpMh2uZ3fUNYHnBARXwFeBC4DkHQccC5wfHrNTSmnvZmZDZEP93V665ykSZL6JG1NfyeWHLcoHbNV0qJC+cmSNqVOyQ1KiaJa1SvpVEkbJW2W1NbOupVBKiIeB3Y0lD0aEfl+0k8wmPxqAXBvRHwUES8D/cDsdhpiZtZ78iXond5G5FJgVURMB1alx7uRNAlYCnyV7H/50kLQuRlYDExPt7wz07TeNOJ2E3B2RBxPmyk82ulJVfkxg3lEjgJeLTxXzHtvZmZD1NOTIutU3JHu3wGc0+SYeUBfROyIiHfJRtHmp4y7B0fE2sjyPd1ZeH1ZvT8A7o+IbQAR0SwT8BAjClKSLgd2AnflRU0Oa5qwStJiSeslrX/nnbdG0gwzs3FqxMN9k/P/o+m2eBhvfnhEvAGQ/h7W5JiyjsdR6X5jeat6vwhMlLRa0gZJC9tpZMer+9LY5FnAaTGYOXEAmFo4rJj3fjcRsQxYBlnSw07bYWY2fo14x4m3WyU9lPQYcESTpy5vs/6yjkfbHZKCfYGTgdPIsvmulfRERLxY9aJhkzQfuAT4ZkR8WHhqBXC3pOuAz5GNUz7VyXuYmXW/0f2dVEScXvacpDclHRkRb6Thu2bDbwPAqYXHU4DVqXxKQ3neISmrd4AsqH4AfCDpceBEssV3pdpZgn4PsBY4VtJAylt/I3AQ0JdWavwZICI2A/cBzwOPAEsiwr9UMzMrVduc1AogX623CHiwyTErgbmSJqYFE3OBlWkY731Jc9KqvoWF15fV+yDwdUn7SjqAbDHGlqpGVvakIuK8JsW3tTj+KuCqqnrNzKzWbZGuBu5LHY9tpNV2kmYBF0bEBRGxQ9KVwLr0misiIl/tfRHZT5Q+Q7Z47uFW9UbEFkmPAM+S/YL51ojY9fvbMhqcTqrPzJmzYs2a9XU3w8xs1E2YoA35PJI0LeB3I6ht0YZWc1LdwNsimZnVxhvMVnGQMjOrjTeYreIgZWZWKwepVhykzMxq48y8VRykzMxq4+G+Kg5SZma18cKJKg5SZma1cU+qioOUmVmtnJm3FQcpM7PaeLivioOUmVltPNxXxUHKzKw2XoJexUHKzKw27klV2RPp483MrGP1pOqQNElSn6St6e/EkuMWpWO2pmS3efnJkjZJ6pd0Q0rZUVqvpAmS/ibpGUmbJZ3fTjsdpMzMapMP93V6G5FLgVURMR1YlR7vRtIkYClZ7qfZwNJCMLsZWEyW3HY6ML+i3iXA8xFxIlkixWsl7VfVSAcpM7Pa5MN9tSQ9XADcke7fAZzT5Jh5QF9E7IiId4E+YH7KuHtwRKyNLN/TnYXXl9UbwEGpx3UgsAPYWdVIz0mZmdWqtjmpw1OGXVKq98OaHHMU8Grh8UAqOyrdbyxvVe+NZFl7XyfL7P79iKj8kZiDlJlZbT5hhL+TmiypmDF2WUQsyx9Iegw4osnrLm+zfjUpixblrcwDNgLfBo4B+iT9MyL+2+pFlUFK0nLgLGB7RJzQ8NyvgGuAQyPi7dSN+wNwJvAh8KOIeLrqPczMeteIelJvt8rMGxGnlz0n6U1JR6bezpHA9iaHDZDNH+WmAKtT+ZSG8tfT/bJ6zweuTsOD/ZJeBr4EPNXqA7YzJ3U7gxNiu0iaCpxBlsM+9x0GJ9EWk02smZlZU7UunFgB5Kv1FgEPNjlmJTBX0sS0YGIusDIN570vaU7qnCwsvL6s3m3AaQCSDgeOBV6qamRlkIqIx8kmuBpdD/ya3bt4C4A7I/MEcEiKpGZmNkStCyeuBs6QtJWsw3E1gKRZkm4FiIgdwJXAunS7IpUBXATcCvQD/wYeblVvqudrkjaRrfq7JCLermpkR3NSks4GXouIZ9LS+FzZJNsbTepYTNbbYurUz3fSDDOzca6+H/NGxDuknk1D+XrggsLj5cDykuNOaFJeVu/rZD2xYRl2kJJ0ANmkW7M3a3syLU3uLUt1vjVhgj4AKqNql5uMzwH4PIDPQa4bz8MXBu++txIenDyCurrt3AzRSU/qGGAakPeipgBPS5pN1nOaWji2OJlWKiIOlbS+1QRgL/A5yPg8+Bzkuv08RMSQ+X7b3bB/zBsRmyLisIg4OiKOJgtMJ0XEf8gmzBYqMwd4L18vb2ZmNlyVQUrSPcBa4FhJA5J+0uLwh8hWa/QDtwA/2yOtNDOznlQ53BcR51U8f3ThfpDtz9SJZdWHdD2fg4zPg89BzuehxymLK2ZmZmOPN5g1M7Mxq/YgJWm+pBdSTpIhW8V3M0mvpHwsG/P9t9rN8TJeSVouabuk5wplZflnlPLU9Et6VtJJ9bV8zyo5D7+V9Fq6HjZKOrPw3GXpPLwgaV49rd6zJE2V9A9JW1J+oZ+n8p67HqxcrUFK0j7An8i2UzoOOE/ScXW2qQbfiogZhWW2lTlexrnbGbrNVtln7uZttm6nyXZjwPXpepgREQ8BpO/EucDx6TU3pe/OeLcT+GVEfBmYAyxJn7UXrwcrUXdPajbQHxEvRcT/gHvJtlbqZe3keBm3SrbZKvvMXbvNVovtxppZANwbER9FxMtkq2dnj1rj9pKIeCPfgDoi3ge2kO1Q03PXg5WrO0iVbaPUKwJ4VNKGtE0UNORiAZrleOk2ZZ+5F6+Pi9NQ1vLCUG/XnwdJRwMzgSfx9WAFdQepTnKSdJNTIuIksmGMJZK+UXeDxpheuz5uJtvRZQbZfpfXpvKuPg+SDgT+AvyiIrdQV58Ha67uINXRNkrdIm24SERsBx4gG8J5Mx/CaJHjpduUfeaeuj4i4s2I+DhlK72FwSG9rj0Pkj5NFqDuioj7U7GvB9ul7iC1DpguaZqk/cgmh1fU3Ka9QtJnJR2U3yfbsPc52svx0m3KPnNPbbPVML/yXbLrAbLzcK6k/SVNI1s40DJR3HiQ8hDdBmyJiOsKT/l6sF1qTR8fETslXUyWWGsfYHlEbK6zTXvR4cADaZPefYG7I+IRSeuA+9L2U9uA79XYxj0ubbN1Klna6wFgKVm+mWaf+SGyLM/9ZJmez9/rDR4lJefhVEkzyIawXgF+ChARmyXdBzxPtiJuSUTUk99hzzoF+CGwSdLGVPYbevB6sHLeccLMzMasuof7zMzMSjlImZnZmOUgZWZmY5aDlJmZjVkOUmZmNmY5SJmZ2ZjlIGVmZmOWg5SZmY1Z/wevJMYd3eUT3gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#NBVAL_IGNORE_OUTPUT\n",
    "\n",
    "# Plots\n",
    "%matplotlib inline\n",
    "\n",
    "# Mid-points:\n",
    "mid_x = int(0.5*(v[0].data.shape[1]-1))+1\n",
    "mid_y = int(0.5*(v[0].data.shape[2]-1))+1\n",
    "\n",
    "# Plot some selected results:\n",
    "\n",
    "plot_image(v[0].data[1, :, mid_y, :], cmap=\"seismic\")\n",
    "plot_image(v[0].data[1, mid_x, :, :], cmap=\"seismic\")\n",
    "\n",
    "plot_image(tau[2, 2].data[1, :, mid_y, :], cmap=\"seismic\")\n",
    "plot_image(tau[2, 2].data[1, mid_x, :, :], cmap=\"seismic\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note:\n",
    "\n",
    "When creating a grid with many subdomains the process introduced in this notebook becomes cumbersome. For such cases the `SubDomainSet` object is available allowing users to easily define a large number of subdomains. A tutorial regarding the use of `SubDomainSet`'s will be released at some point in the future."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
